[hibernate-commits] Hibernate SVN: r14128 - in core/trunk/documentation/manual: pot and 14 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Mon Oct 22 11:48:12 EDT 2007
Author: steve.ebersole at jboss.com
Date: 2007-10-22 11:48:10 -0400 (Mon, 22 Oct 2007)
New Revision: 14128
Added:
core/trunk/documentation/manual/pot/
core/trunk/documentation/manual/pot/Hibernate_Reference.pot
core/trunk/documentation/manual/pot/content/
core/trunk/documentation/manual/pot/content/architecture.pot
core/trunk/documentation/manual/pot/content/association_mapping.pot
core/trunk/documentation/manual/pot/content/basic_mapping.pot
core/trunk/documentation/manual/pot/content/batch.pot
core/trunk/documentation/manual/pot/content/best_practices.pot
core/trunk/documentation/manual/pot/content/collection_mapping.pot
core/trunk/documentation/manual/pot/content/component_mapping.pot
core/trunk/documentation/manual/pot/content/configuration.pot
core/trunk/documentation/manual/pot/content/events.pot
core/trunk/documentation/manual/pot/content/example_mappings.pot
core/trunk/documentation/manual/pot/content/example_parentchild.pot
core/trunk/documentation/manual/pot/content/example_weblog.pot
core/trunk/documentation/manual/pot/content/filters.pot
core/trunk/documentation/manual/pot/content/inheritance_mapping.pot
core/trunk/documentation/manual/pot/content/performance.pot
core/trunk/documentation/manual/pot/content/persistent_classes.pot
core/trunk/documentation/manual/pot/content/preface.pot
core/trunk/documentation/manual/pot/content/query_criteria.pot
core/trunk/documentation/manual/pot/content/query_hql.pot
core/trunk/documentation/manual/pot/content/query_sql.pot
core/trunk/documentation/manual/pot/content/session_api.pot
core/trunk/documentation/manual/pot/content/toolset_guide.pot
core/trunk/documentation/manual/pot/content/transactions.pot
core/trunk/documentation/manual/pot/content/tutorial.pot
core/trunk/documentation/manual/pot/content/xml.pot
core/trunk/documentation/manual/pot/legal_notice.pot
core/trunk/documentation/manual/translations/
core/trunk/documentation/manual/translations/es-ES/
core/trunk/documentation/manual/translations/es-ES/Hibernate_Reference.po
core/trunk/documentation/manual/translations/es-ES/content/
core/trunk/documentation/manual/translations/es-ES/content/architecture.po
core/trunk/documentation/manual/translations/es-ES/content/association_mapping.po
core/trunk/documentation/manual/translations/es-ES/content/basic_mapping.po
core/trunk/documentation/manual/translations/es-ES/content/batch.po
core/trunk/documentation/manual/translations/es-ES/content/best_practices.po
core/trunk/documentation/manual/translations/es-ES/content/collection_mapping.po
core/trunk/documentation/manual/translations/es-ES/content/component_mapping.po
core/trunk/documentation/manual/translations/es-ES/content/configuration.po
core/trunk/documentation/manual/translations/es-ES/content/events.po
core/trunk/documentation/manual/translations/es-ES/content/example_mappings.po
core/trunk/documentation/manual/translations/es-ES/content/example_parentchild.po
core/trunk/documentation/manual/translations/es-ES/content/example_weblog.po
core/trunk/documentation/manual/translations/es-ES/content/filters.po
core/trunk/documentation/manual/translations/es-ES/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/es-ES/content/performance.po
core/trunk/documentation/manual/translations/es-ES/content/persistent_classes.po
core/trunk/documentation/manual/translations/es-ES/content/preface.po
core/trunk/documentation/manual/translations/es-ES/content/query_criteria.po
core/trunk/documentation/manual/translations/es-ES/content/query_hql.po
core/trunk/documentation/manual/translations/es-ES/content/query_sql.po
core/trunk/documentation/manual/translations/es-ES/content/quickstart.po
core/trunk/documentation/manual/translations/es-ES/content/session_api.po
core/trunk/documentation/manual/translations/es-ES/content/toolset_guide.po
core/trunk/documentation/manual/translations/es-ES/content/transactions.po
core/trunk/documentation/manual/translations/es-ES/content/tutorial.po
core/trunk/documentation/manual/translations/es-ES/content/xml.po
core/trunk/documentation/manual/translations/es-ES/legal_notice.po
core/trunk/documentation/manual/translations/fr-FR/
core/trunk/documentation/manual/translations/fr-FR/Hibernate_Reference.po
core/trunk/documentation/manual/translations/fr-FR/content/
core/trunk/documentation/manual/translations/fr-FR/content/architecture.po
core/trunk/documentation/manual/translations/fr-FR/content/association_mapping.po
core/trunk/documentation/manual/translations/fr-FR/content/basic_mapping.po
core/trunk/documentation/manual/translations/fr-FR/content/batch.po
core/trunk/documentation/manual/translations/fr-FR/content/best_practices.po
core/trunk/documentation/manual/translations/fr-FR/content/collection_mapping.po
core/trunk/documentation/manual/translations/fr-FR/content/component_mapping.po
core/trunk/documentation/manual/translations/fr-FR/content/configuration.po
core/trunk/documentation/manual/translations/fr-FR/content/events.po
core/trunk/documentation/manual/translations/fr-FR/content/example_mappings.po
core/trunk/documentation/manual/translations/fr-FR/content/example_parentchild.po
core/trunk/documentation/manual/translations/fr-FR/content/example_weblog.po
core/trunk/documentation/manual/translations/fr-FR/content/filters.po
core/trunk/documentation/manual/translations/fr-FR/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/fr-FR/content/performance.po
core/trunk/documentation/manual/translations/fr-FR/content/persistent_classes.po
core/trunk/documentation/manual/translations/fr-FR/content/preface.po
core/trunk/documentation/manual/translations/fr-FR/content/query_criteria.po
core/trunk/documentation/manual/translations/fr-FR/content/query_hql.po
core/trunk/documentation/manual/translations/fr-FR/content/query_sql.po
core/trunk/documentation/manual/translations/fr-FR/content/quickstart.po
core/trunk/documentation/manual/translations/fr-FR/content/session_api.po
core/trunk/documentation/manual/translations/fr-FR/content/toolset_guide.po
core/trunk/documentation/manual/translations/fr-FR/content/transactions.po
core/trunk/documentation/manual/translations/fr-FR/content/tutorial.po
core/trunk/documentation/manual/translations/fr-FR/content/xml.po
core/trunk/documentation/manual/translations/fr-FR/legal_notice.po
core/trunk/documentation/manual/translations/ja-JP/
core/trunk/documentation/manual/translations/ja-JP/Hibernate_Reference.po
core/trunk/documentation/manual/translations/ja-JP/content/
core/trunk/documentation/manual/translations/ja-JP/content/architecture.po
core/trunk/documentation/manual/translations/ja-JP/content/association_mapping.po
core/trunk/documentation/manual/translations/ja-JP/content/basic_mapping.po
core/trunk/documentation/manual/translations/ja-JP/content/batch.po
core/trunk/documentation/manual/translations/ja-JP/content/best_practices.po
core/trunk/documentation/manual/translations/ja-JP/content/collection_mapping.po
core/trunk/documentation/manual/translations/ja-JP/content/component_mapping.po
core/trunk/documentation/manual/translations/ja-JP/content/configuration.po
core/trunk/documentation/manual/translations/ja-JP/content/events.po
core/trunk/documentation/manual/translations/ja-JP/content/example_mappings.po
core/trunk/documentation/manual/translations/ja-JP/content/example_parentchild.po
core/trunk/documentation/manual/translations/ja-JP/content/example_weblog.po
core/trunk/documentation/manual/translations/ja-JP/content/filters.po
core/trunk/documentation/manual/translations/ja-JP/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/ja-JP/content/performance.po
core/trunk/documentation/manual/translations/ja-JP/content/persistent_classes.po
core/trunk/documentation/manual/translations/ja-JP/content/preface.po
core/trunk/documentation/manual/translations/ja-JP/content/query_criteria.po
core/trunk/documentation/manual/translations/ja-JP/content/query_hql.po
core/trunk/documentation/manual/translations/ja-JP/content/query_sql.po
core/trunk/documentation/manual/translations/ja-JP/content/quickstart.po
core/trunk/documentation/manual/translations/ja-JP/content/session_api.po
core/trunk/documentation/manual/translations/ja-JP/content/toolset_guide.po
core/trunk/documentation/manual/translations/ja-JP/content/transactions.po
core/trunk/documentation/manual/translations/ja-JP/content/tutorial.po
core/trunk/documentation/manual/translations/ja-JP/content/xml.po
core/trunk/documentation/manual/translations/ja-JP/legal_notice.po
core/trunk/documentation/manual/translations/ko-KR/
core/trunk/documentation/manual/translations/ko-KR/Hibernate_Reference.po
core/trunk/documentation/manual/translations/ko-KR/content/
core/trunk/documentation/manual/translations/ko-KR/content/architecture.po
core/trunk/documentation/manual/translations/ko-KR/content/association_mapping.po
core/trunk/documentation/manual/translations/ko-KR/content/basic_mapping.po
core/trunk/documentation/manual/translations/ko-KR/content/batch.po
core/trunk/documentation/manual/translations/ko-KR/content/best_practices.po
core/trunk/documentation/manual/translations/ko-KR/content/collection_mapping.po
core/trunk/documentation/manual/translations/ko-KR/content/component_mapping.po
core/trunk/documentation/manual/translations/ko-KR/content/configuration.po
core/trunk/documentation/manual/translations/ko-KR/content/events.po
core/trunk/documentation/manual/translations/ko-KR/content/example_mappings.po
core/trunk/documentation/manual/translations/ko-KR/content/example_parentchild.po
core/trunk/documentation/manual/translations/ko-KR/content/example_weblog.po
core/trunk/documentation/manual/translations/ko-KR/content/filters.po
core/trunk/documentation/manual/translations/ko-KR/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/ko-KR/content/performance.po
core/trunk/documentation/manual/translations/ko-KR/content/persistent_classes.po
core/trunk/documentation/manual/translations/ko-KR/content/preface.po
core/trunk/documentation/manual/translations/ko-KR/content/query_criteria.po
core/trunk/documentation/manual/translations/ko-KR/content/query_hql.po
core/trunk/documentation/manual/translations/ko-KR/content/query_sql.po
core/trunk/documentation/manual/translations/ko-KR/content/quickstart.po
core/trunk/documentation/manual/translations/ko-KR/content/session_api.po
core/trunk/documentation/manual/translations/ko-KR/content/toolset_guide.po
core/trunk/documentation/manual/translations/ko-KR/content/transactions.po
core/trunk/documentation/manual/translations/ko-KR/content/tutorial.po
core/trunk/documentation/manual/translations/ko-KR/content/xml.po
core/trunk/documentation/manual/translations/ko-KR/legal_notice.po
core/trunk/documentation/manual/translations/pt-BR/
core/trunk/documentation/manual/translations/pt-BR/Hibernate_Reference.po
core/trunk/documentation/manual/translations/pt-BR/content/
core/trunk/documentation/manual/translations/pt-BR/content/architecture.po
core/trunk/documentation/manual/translations/pt-BR/content/association_mapping.po
core/trunk/documentation/manual/translations/pt-BR/content/basic_mapping.po
core/trunk/documentation/manual/translations/pt-BR/content/batch.po
core/trunk/documentation/manual/translations/pt-BR/content/best_practices.po
core/trunk/documentation/manual/translations/pt-BR/content/collection_mapping.po
core/trunk/documentation/manual/translations/pt-BR/content/component_mapping.po
core/trunk/documentation/manual/translations/pt-BR/content/configuration.po
core/trunk/documentation/manual/translations/pt-BR/content/events.po
core/trunk/documentation/manual/translations/pt-BR/content/example_mappings.po
core/trunk/documentation/manual/translations/pt-BR/content/example_parentchild.po
core/trunk/documentation/manual/translations/pt-BR/content/example_weblog.po
core/trunk/documentation/manual/translations/pt-BR/content/filters.po
core/trunk/documentation/manual/translations/pt-BR/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/pt-BR/content/performance.po
core/trunk/documentation/manual/translations/pt-BR/content/persistent_classes.po
core/trunk/documentation/manual/translations/pt-BR/content/preface.po
core/trunk/documentation/manual/translations/pt-BR/content/query_criteria.po
core/trunk/documentation/manual/translations/pt-BR/content/query_hql.po
core/trunk/documentation/manual/translations/pt-BR/content/query_sql.po
core/trunk/documentation/manual/translations/pt-BR/content/quickstart.po
core/trunk/documentation/manual/translations/pt-BR/content/session_api.po
core/trunk/documentation/manual/translations/pt-BR/content/toolset_guide.po
core/trunk/documentation/manual/translations/pt-BR/content/transactions.po
core/trunk/documentation/manual/translations/pt-BR/content/tutorial.po
core/trunk/documentation/manual/translations/pt-BR/content/xml.po
core/trunk/documentation/manual/translations/pt-BR/legal_notice.po
core/trunk/documentation/manual/translations/zh-CN/
core/trunk/documentation/manual/translations/zh-CN/Hibernate_Reference.po
core/trunk/documentation/manual/translations/zh-CN/content/
core/trunk/documentation/manual/translations/zh-CN/content/architecture.po
core/trunk/documentation/manual/translations/zh-CN/content/association_mapping.po
core/trunk/documentation/manual/translations/zh-CN/content/basic_mapping.po
core/trunk/documentation/manual/translations/zh-CN/content/batch.po
core/trunk/documentation/manual/translations/zh-CN/content/best_practices.po
core/trunk/documentation/manual/translations/zh-CN/content/collection_mapping.po
core/trunk/documentation/manual/translations/zh-CN/content/component_mapping.po
core/trunk/documentation/manual/translations/zh-CN/content/configuration.po
core/trunk/documentation/manual/translations/zh-CN/content/events.po
core/trunk/documentation/manual/translations/zh-CN/content/example_mappings.po
core/trunk/documentation/manual/translations/zh-CN/content/example_parentchild.po
core/trunk/documentation/manual/translations/zh-CN/content/example_weblog.po
core/trunk/documentation/manual/translations/zh-CN/content/filters.po
core/trunk/documentation/manual/translations/zh-CN/content/inheritance_mapping.po
core/trunk/documentation/manual/translations/zh-CN/content/performance.po
core/trunk/documentation/manual/translations/zh-CN/content/persistent_classes.po
core/trunk/documentation/manual/translations/zh-CN/content/preface.po
core/trunk/documentation/manual/translations/zh-CN/content/query_criteria.po
core/trunk/documentation/manual/translations/zh-CN/content/query_hql.po
core/trunk/documentation/manual/translations/zh-CN/content/query_sql.po
core/trunk/documentation/manual/translations/zh-CN/content/quickstart.po
core/trunk/documentation/manual/translations/zh-CN/content/session_api.po
core/trunk/documentation/manual/translations/zh-CN/content/toolset_guide.po
core/trunk/documentation/manual/translations/zh-CN/content/transactions.po
core/trunk/documentation/manual/translations/zh-CN/content/tutorial.po
core/trunk/documentation/manual/translations/zh-CN/content/xml.po
core/trunk/documentation/manual/translations/zh-CN/legal_notice.po
Log:
translation po/gettext conversion
Added: core/trunk/documentation/manual/pot/Hibernate_Reference.pot
===================================================================
--- core/trunk/documentation/manual/pot/Hibernate_Reference.pot (rev 0)
+++ core/trunk/documentation/manual/pot/Hibernate_Reference.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,34 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:23-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: ./Hibernate_Reference.xml:33(None) ./Hibernate_Reference.xml:36(None)
+msgid "@@image: 'images/hibernate_logo_a.png'; md5=38bd6cfd79e676660440f316f4ab452c"
+msgstr ""
+
+#: ./Hibernate_Reference.xml:26(title)
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr ""
+
+#: ./Hibernate_Reference.xml:27(subtitle)
+msgid "Hibernate Reference Documentation"
+msgstr ""
+
+#: ./Hibernate_Reference.xml:30(issuenum)
+msgid "1"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: ./Hibernate_Reference.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/architecture.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/architecture.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/architecture.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,256 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:28-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:32(None)
+msgid "@@image: '../images/overview.svg'; md5=2d9211eace02ecef615f7dd42beec14c"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:35(None)
+msgid "@@image: '../images/overview.png'; md5=a2b5f0f7dc75d9773305d4d824880e8c"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:54(None)
+msgid "@@image: '../images/lite.svg'; md5=2178e70b3b165736d33b085dcad93699"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:57(None)
+msgid "@@image: '../images/lite.png'; md5=7dd864188937e2dfef42a706235f74c3"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:68(None)
+msgid "@@image: '../images/full_cream.svg'; md5=4ef192f03e90e451e5dcb287d2709687"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: architecture.xml:71(None)
+msgid "@@image: '../images/full_cream.png'; md5=c3ee197b49364a876bc5867d5c2c6db7"
+msgstr ""
+
+#: architecture.xml:21(title)
+msgid "Architecture"
+msgstr ""
+
+#: architecture.xml:24(title)
+msgid "Overview"
+msgstr ""
+
+#: architecture.xml:26(para)
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr ""
+
+#: architecture.xml:39(para)
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr ""
+
+#: architecture.xml:44(para)
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 ""
+
+#: architecture.xml:61(para)
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr ""
+
+#: architecture.xml:80(term)
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr ""
+
+#: architecture.xml:82(para)
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr ""
+
+#: architecture.xml:92(term)
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr ""
+
+#: architecture.xml:94(para)
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr ""
+
+#: architecture.xml:104(term)
+msgid "Persistent objects and collections"
+msgstr ""
+
+#: architecture.xml:106(para)
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr ""
+
+#: architecture.xml:117(term)
+msgid "Transient and detached objects and collections"
+msgstr ""
+
+#: architecture.xml:119(para)
+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 ""
+
+#: architecture.xml:128(term)
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr ""
+
+#: architecture.xml:130(para)
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 ""
+
+#: architecture.xml:141(term)
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr ""
+
+#: architecture.xml:143(para)
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: architecture.xml:151(term)
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr ""
+
+#: architecture.xml:153(para)
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: architecture.xml:160(emphasis)
+msgid "Extension Interfaces"
+msgstr ""
+
+#: architecture.xml:162(para)
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr ""
+
+#: architecture.xml:75(para)
+msgid "Heres some definitions of the objects in the diagrams: <placeholder-1/>"
+msgstr ""
+
+#: architecture.xml:171(para)
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr ""
+
+#: architecture.xml:179(title)
+msgid "Instance states"
+msgstr ""
+
+#: architecture.xml:180(para)
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr ""
+
+#: architecture.xml:188(term)
+msgid "transient"
+msgstr ""
+
+#: architecture.xml:190(para)
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr ""
+
+#: architecture.xml:198(term)
+msgid "persistent"
+msgstr ""
+
+#: architecture.xml:200(para)
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr ""
+
+#: architecture.xml:212(term)
+msgid "detached"
+msgstr ""
+
+#: architecture.xml:214(para)
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr ""
+
+#: architecture.xml:229(title)
+msgid "JMX Integration"
+msgstr ""
+
+#: architecture.xml:231(para)
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr ""
+
+#: architecture.xml:237(para)
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr ""
+
+#: architecture.xml:245(para)
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr ""
+
+#: architecture.xml:257(para)
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr ""
+
+#: architecture.xml:268(para)
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr ""
+
+#: architecture.xml:272(para)
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr ""
+
+#: architecture.xml:279(title)
+msgid "JCA Support"
+msgstr ""
+
+#: architecture.xml:280(para)
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr ""
+
+#: architecture.xml:287(title)
+msgid "Contextual Sessions"
+msgstr ""
+
+#: architecture.xml:288(para)
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 ""
+
+#: architecture.xml:297(para)
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr ""
+
+#: architecture.xml:307(para)
+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 ""
+
+#: architecture.xml:314(para)
+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 ""
+
+#: architecture.xml:324(para)
+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 ""
+
+#: architecture.xml:332(para)
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr ""
+
+#: architecture.xml:338(para)
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr ""
+
+#: architecture.xml:347(para)
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr ""
+
+#: architecture.xml:359(para)
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: architecture.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/association_mapping.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/association_mapping.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/association_mapping.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,160 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:28-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: association_mapping.xml:6(title)
+msgid "Association Mappings"
+msgstr ""
+
+#: association_mapping.xml:9(title)
+msgid "Introduction"
+msgstr ""
+
+#: association_mapping.xml:11(para)
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr ""
+
+#: association_mapping.xml:19(para)
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr ""
+
+#: association_mapping.xml:24(para)
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr ""
+
+#: association_mapping.xml:34(title)
+msgid "Unidirectional associations"
+msgstr ""
+
+#: association_mapping.xml:37(title) association_mapping.xml:195(title)
+msgid "many to one"
+msgstr ""
+
+#: association_mapping.xml:39(para)
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr ""
+
+#: association_mapping.xml:66(title) association_mapping.xml:229(title) association_mapping.xml:373(title) association_mapping.xml:479(title)
+msgid "one to one"
+msgstr ""
+
+#: association_mapping.xml:68(para)
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr ""
+
+#: association_mapping.xml:93(para)
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr ""
+
+#: association_mapping.xml:121(title) association_mapping.xml:161(title)
+msgid "one to many"
+msgstr ""
+
+#: association_mapping.xml:123(para)
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr ""
+
+#: association_mapping.xml:149(para)
+msgid "We think it's better to use a join table for this kind of association."
+msgstr ""
+
+#: association_mapping.xml:158(title)
+msgid "Unidirectional associations with join tables"
+msgstr ""
+
+#: association_mapping.xml:163(para)
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr ""
+
+#: association_mapping.xml:197(para)
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr ""
+
+#: association_mapping.xml:231(para)
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: association_mapping.xml:265(title) association_mapping.xml:525(title)
+msgid "many to many"
+msgstr ""
+
+#: association_mapping.xml:267(para)
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: association_mapping.xml:298(title)
+msgid "Bidirectional associations"
+msgstr ""
+
+#: association_mapping.xml:301(title) association_mapping.xml:436(title)
+msgid "one to many / many to one"
+msgstr ""
+
+#: association_mapping.xml:303(para)
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr ""
+
+#: association_mapping.xml:333(para)
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr ""
+
+#: association_mapping.xml:361(para)
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr ""
+
+#: association_mapping.xml:375(para)
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr ""
+
+#: association_mapping.xml:402(para)
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr ""
+
+#: association_mapping.xml:433(title)
+msgid "Bidirectional associations with join tables"
+msgstr ""
+
+#: association_mapping.xml:438(para)
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr ""
+
+#: association_mapping.xml:481(para)
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: association_mapping.xml:527(para)
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: association_mapping.xml:564(title)
+msgid "More complex association mappings"
+msgstr ""
+
+#: association_mapping.xml:566(para)
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr ""
+
+#: association_mapping.xml:584(para)
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr ""
+
+#: association_mapping.xml:596(para)
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr ""
+
+#: association_mapping.xml:617(para)
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: association_mapping.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/basic_mapping.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/basic_mapping.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/basic_mapping.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1532 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:29-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: basic_mapping.xml:5(title)
+msgid "Basic O/R Mapping"
+msgstr ""
+
+#: basic_mapping.xml:8(title)
+msgid "Mapping declaration"
+msgstr ""
+
+#: basic_mapping.xml:10(para)
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr ""
+
+#: basic_mapping.xml:17(para)
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr ""
+
+#: basic_mapping.xml:23(para)
+msgid "Lets kick off with an example mapping:"
+msgstr ""
+
+#: basic_mapping.xml:92(para)
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr ""
+
+#: basic_mapping.xml:103(title)
+msgid "Doctype"
+msgstr ""
+
+#: basic_mapping.xml:105(para)
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr ""
+
+#: basic_mapping.xml:115(title)
+msgid "EntityResolver"
+msgstr ""
+
+#: basic_mapping.xml:116(para)
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr ""
+
+#: basic_mapping.xml:124(para)
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr ""
+
+#: basic_mapping.xml:133(para)
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr ""
+
+#: basic_mapping.xml:142(para)
+msgid "An example of utilizing user namespacing:"
+msgstr ""
+
+#: basic_mapping.xml:160(para)
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\">typedef</xref>."
+msgstr ""
+
+#: basic_mapping.xml:168(title)
+msgid "hibernate-mapping"
+msgstr ""
+
+#: basic_mapping.xml:170(para)
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr ""
+
+#: basic_mapping.xml:202(para)
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr ""
+
+#: basic_mapping.xml:207(para)
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr ""
+
+#: basic_mapping.xml:212(para)
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr ""
+
+#: basic_mapping.xml:218(para)
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr ""
+
+#: basic_mapping.xml:225(para)
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr ""
+
+#: basic_mapping.xml:232(para)
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr ""
+
+#: basic_mapping.xml:239(para)
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr ""
+
+#: basic_mapping.xml:247(para)
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr ""
+
+#: basic_mapping.xml:253(para)
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr ""
+
+#: basic_mapping.xml:266(title) basic_mapping.xml:3077(literal)
+msgid "class"
+msgstr ""
+
+#: basic_mapping.xml:268(para)
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr ""
+
+#: basic_mapping.xml:322(para)
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr ""
+
+#: basic_mapping.xml:329(para)
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr ""
+
+#: basic_mapping.xml:335(para)
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr ""
+
+#: basic_mapping.xml:342(para)
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr ""
+
+#: basic_mapping.xml:348(para) basic_mapping.xml:2605(para)
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:354(para) basic_mapping.xml:2611(para)
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:360(para)
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr ""
+
+#: basic_mapping.xml:366(para)
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr ""
+
+#: basic_mapping.xml:373(para)
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr ""
+
+#: basic_mapping.xml:380(para)
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr ""
+
+#: basic_mapping.xml:390(para)
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr ""
+
+#: basic_mapping.xml:396(para)
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr ""
+
+#: basic_mapping.xml:402(para)
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr ""
+
+#: basic_mapping.xml:407(para)
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr ""
+
+#: basic_mapping.xml:413(para)
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr ""
+
+#: basic_mapping.xml:419(para)
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: basic_mapping.xml:425(para)
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr ""
+
+#: basic_mapping.xml:435(para)
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr ""
+
+#: basic_mapping.xml:441(para)
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr ""
+
+#: basic_mapping.xml:449(para)
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr ""
+
+#: basic_mapping.xml:456(para)
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr ""
+
+#: basic_mapping.xml:464(para)
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr ""
+
+#: basic_mapping.xml:471(para)
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr ""
+
+#: basic_mapping.xml:476(para)
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr ""
+
+#: basic_mapping.xml:483(para)
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr ""
+
+#: basic_mapping.xml:495(para)
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:506(para)
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr ""
+
+#: basic_mapping.xml:514(para)
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr ""
+
+#: basic_mapping.xml:520(para)
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr ""
+
+#: basic_mapping.xml:526(para)
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr ""
+
+#: basic_mapping.xml:531(para)
+msgid "<literal>all</literal> check all columns"
+msgstr ""
+
+#: basic_mapping.xml:536(para)
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr ""
+
+#: basic_mapping.xml:541(para)
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr ""
+
+#: basic_mapping.xml:546(para)
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr ""
+
+#: basic_mapping.xml:553(para)
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr ""
+
+#: basic_mapping.xml:574(para)
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr ""
+
+#: basic_mapping.xml:584(title)
+msgid "id"
+msgstr ""
+
+#: basic_mapping.xml:586(para)
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr ""
+
+#: basic_mapping.xml:613(para)
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr ""
+
+#: basic_mapping.xml:618(para)
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr ""
+
+#: basic_mapping.xml:623(para)
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr ""
+
+#: basic_mapping.xml:629(para)
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr ""
+
+#: basic_mapping.xml:637(para) basic_mapping.xml:1187(para) basic_mapping.xml:1343(para) basic_mapping.xml:1433(para) basic_mapping.xml:1559(para) basic_mapping.xml:1775(para) basic_mapping.xml:1963(para) basic_mapping.xml:2162(para) basic_mapping.xml:2914(para)
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr ""
+
+#: basic_mapping.xml:645(para)
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr ""
+
+#: basic_mapping.xml:650(para)
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr ""
+
+#: basic_mapping.xml:654(para)
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr ""
+
+#: basic_mapping.xml:660(title)
+msgid "Generator"
+msgstr ""
+
+#: basic_mapping.xml:662(para)
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:684(literal)
+msgid "increment"
+msgstr ""
+
+#: basic_mapping.xml:686(para)
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr ""
+
+#: basic_mapping.xml:695(literal)
+msgid "identity"
+msgstr ""
+
+#: basic_mapping.xml:697(para)
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr ""
+
+#: basic_mapping.xml:705(literal)
+msgid "sequence"
+msgstr ""
+
+#: basic_mapping.xml:707(para)
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr ""
+
+#: basic_mapping.xml:715(literal)
+msgid "hilo"
+msgstr ""
+
+#: basic_mapping.xml:717(para)
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr ""
+
+#: basic_mapping.xml:727(literal)
+msgid "seqhilo"
+msgstr ""
+
+#: basic_mapping.xml:729(para)
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr ""
+
+#: basic_mapping.xml:737(literal)
+msgid "uuid"
+msgstr ""
+
+#: basic_mapping.xml:739(para)
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr ""
+
+#: basic_mapping.xml:747(literal)
+msgid "guid"
+msgstr ""
+
+#: basic_mapping.xml:749(para)
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr ""
+
+#: basic_mapping.xml:755(literal)
+msgid "native"
+msgstr ""
+
+#: basic_mapping.xml:757(para)
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr ""
+
+#: basic_mapping.xml:765(literal)
+msgid "assigned"
+msgstr ""
+
+#: basic_mapping.xml:767(para)
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr ""
+
+#: basic_mapping.xml:775(literal)
+msgid "select"
+msgstr ""
+
+#: basic_mapping.xml:777(para)
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr ""
+
+#: basic_mapping.xml:784(literal)
+msgid "foreign"
+msgstr ""
+
+#: basic_mapping.xml:786(para)
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr ""
+
+#: basic_mapping.xml:793(literal)
+msgid "sequence-identity"
+msgstr ""
+
+#: basic_mapping.xml:795(para)
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr ""
+
+#: basic_mapping.xml:676(para)
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators: <placeholder-1/>"
+msgstr ""
+
+#: basic_mapping.xml:812(title)
+msgid "Hi/lo algorithm"
+msgstr ""
+
+#: basic_mapping.xml:813(para)
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+
+#: basic_mapping.xml:835(para)
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: basic_mapping.xml:844(title)
+msgid "UUID algorithm"
+msgstr ""
+
+#: basic_mapping.xml:845(para)
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr ""
+
+#: basic_mapping.xml:854(title)
+msgid "Identity columns and sequences"
+msgstr ""
+
+#: basic_mapping.xml:855(para)
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr ""
+
+#: basic_mapping.xml:873(para)
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr ""
+
+#: basic_mapping.xml:882(title)
+msgid "Assigned identifiers"
+msgstr ""
+
+#: basic_mapping.xml:883(para)
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:892(para)
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr ""
+
+#: basic_mapping.xml:902(title)
+msgid "Primary keys assigned by triggers"
+msgstr ""
+
+#: basic_mapping.xml:903(para)
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr ""
+
+#: basic_mapping.xml:913(para)
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr ""
+
+#: basic_mapping.xml:925(title)
+msgid "Enhanced identifier generators"
+msgstr ""
+
+#: basic_mapping.xml:927(para)
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr ""
+
+#: basic_mapping.xml:949(para)
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr ""
+
+#: basic_mapping.xml:955(para)
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr ""
+
+#: basic_mapping.xml:962(para)
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr ""
+
+#: basic_mapping.xml:969(para)
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr ""
+
+#: basic_mapping.xml:976(para)
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: basic_mapping.xml:983(para)
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\"/>"
+msgstr ""
+
+#: basic_mapping.xml:935(para)
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters: <placeholder-1/>"
+msgstr ""
+
+#: basic_mapping.xml:1000(para)
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr ""
+
+#: basic_mapping.xml:1006(para)
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: basic_mapping.xml:1012(para)
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr ""
+
+#: basic_mapping.xml:1019(para)
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr ""
+
+#: basic_mapping.xml:1026(para)
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr ""
+
+#: basic_mapping.xml:1032(para)
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr ""
+
+#: basic_mapping.xml:1038(para)
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr ""
+
+#: basic_mapping.xml:1044(para)
+msgid "<literal>optimizer</literal> (optional, defaults to <literal/>): See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\"/>"
+msgstr ""
+
+#: basic_mapping.xml:990(para)
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters: <placeholder-1/>"
+msgstr ""
+
+#: basic_mapping.xml:1054(title)
+msgid "Identifier generator optimization"
+msgstr ""
+
+#: basic_mapping.xml:1063(para)
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr ""
+
+#: basic_mapping.xml:1069(para)
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr ""
+
+#: basic_mapping.xml:1078(para)
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr ""
+
+#: basic_mapping.xml:1055(para)
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion. <placeholder-1/>"
+msgstr ""
+
+#: basic_mapping.xml:1091(title)
+msgid "composite-id"
+msgstr ""
+
+#: basic_mapping.xml:1105(para)
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr ""
+
+#: basic_mapping.xml:1117(para)
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1123(para)
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr ""
+
+#: basic_mapping.xml:1132(para)
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr ""
+
+#: basic_mapping.xml:1143(para)
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr ""
+
+#: basic_mapping.xml:1152(para)
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr ""
+
+#: basic_mapping.xml:1158(para)
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr ""
+
+#: basic_mapping.xml:1166(para)
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr ""
+
+#: basic_mapping.xml:1173(para)
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr ""
+
+#: basic_mapping.xml:1181(para)
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr ""
+
+#: basic_mapping.xml:1193(para)
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr ""
+
+#: basic_mapping.xml:1200(para)
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr ""
+
+#: basic_mapping.xml:1208(title)
+msgid "discriminator"
+msgstr ""
+
+#: basic_mapping.xml:1210(para)
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1237(para)
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr ""
+
+#: basic_mapping.xml:1243(para)
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr ""
+
+#: basic_mapping.xml:1249(para)
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr ""
+
+#: basic_mapping.xml:1256(para)
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr ""
+
+#: basic_mapping.xml:1264(para)
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr ""
+
+#: basic_mapping.xml:1272(para)
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr ""
+
+#: basic_mapping.xml:1278(para)
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr ""
+
+#: basic_mapping.xml:1284(para)
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr ""
+
+#: basic_mapping.xml:1296(title)
+msgid "version (optional)"
+msgstr ""
+
+#: basic_mapping.xml:1298(para)
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr ""
+
+#: basic_mapping.xml:1326(para)
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr ""
+
+#: basic_mapping.xml:1332(para)
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr ""
+
+#: basic_mapping.xml:1337(para)
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr ""
+
+#: basic_mapping.xml:1349(para)
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: basic_mapping.xml:1358(para)
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\">generated properties</xref>."
+msgstr ""
+
+#: basic_mapping.xml:1365(para)
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1375(para)
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1380(para)
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr ""
+
+#: basic_mapping.xml:1391(title)
+msgid "timestamp (optional)"
+msgstr ""
+
+#: basic_mapping.xml:1393(para)
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr ""
+
+#: basic_mapping.xml:1420(para)
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr ""
+
+#: basic_mapping.xml:1426(para)
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr ""
+
+#: basic_mapping.xml:1439(para)
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: basic_mapping.xml:1448(para)
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr ""
+
+#: basic_mapping.xml:1460(para)
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\">generated properties</xref>."
+msgstr ""
+
+#: basic_mapping.xml:1469(para)
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr ""
+
+#: basic_mapping.xml:1479(title)
+msgid "property"
+msgstr ""
+
+#: basic_mapping.xml:1481(para)
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr ""
+
+#: basic_mapping.xml:1525(para)
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr ""
+
+#: basic_mapping.xml:1531(para)
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: basic_mapping.xml:1538(para)
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr ""
+
+#: basic_mapping.xml:1543(para)
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: basic_mapping.xml:1552(para)
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr ""
+
+#: basic_mapping.xml:1565(para)
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: basic_mapping.xml:1572(para)
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1579(para)
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr ""
+
+#: basic_mapping.xml:1585(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: basic_mapping.xml:1593(para)
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\">generated properties</xref>."
+msgstr ""
+
+#: basic_mapping.xml:1602(para)
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr ""
+
+#: basic_mapping.xml:1608(para)
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:1614(para)
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:1620(para)
+msgid "The name of a serializable Java class."
+msgstr ""
+
+#: basic_mapping.xml:1625(para)
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:1631(para)
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr ""
+
+#: basic_mapping.xml:1641(para)
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr ""
+
+#: basic_mapping.xml:1650(para)
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr ""
+
+#: basic_mapping.xml:1664(para)
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr ""
+
+#: basic_mapping.xml:1674(title)
+msgid "many-to-one"
+msgstr ""
+
+#: basic_mapping.xml:1676(para)
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr ""
+
+#: basic_mapping.xml:1729(para) basic_mapping.xml:1924(para) basic_mapping.xml:2139(para)
+msgid "<literal>name</literal>: The name of the property."
+msgstr ""
+
+#: basic_mapping.xml:1734(para) basic_mapping.xml:2703(para)
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: basic_mapping.xml:1741(para) basic_mapping.xml:1929(para)
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr ""
+
+#: basic_mapping.xml:1747(para)
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: basic_mapping.xml:1753(para) basic_mapping.xml:1950(para)
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr ""
+
+#: basic_mapping.xml:1759(para)
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: basic_mapping.xml:1768(para)
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: basic_mapping.xml:1781(para)
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr ""
+
+#: basic_mapping.xml:1789(para)
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr ""
+
+#: basic_mapping.xml:1795(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: basic_mapping.xml:1803(para)
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr ""
+
+#: basic_mapping.xml:1813(para)
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: basic_mapping.xml:1820(para) basic_mapping.xml:1988(para)
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr ""
+
+#: basic_mapping.xml:1826(para)
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr ""
+
+#: basic_mapping.xml:1833(para)
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr ""
+
+#: basic_mapping.xml:1846(para)
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr ""
+
+#: basic_mapping.xml:1852(para)
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr ""
+
+#: basic_mapping.xml:1863(para)
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr ""
+
+#: basic_mapping.xml:1869(para)
+msgid "This is certainly not encouraged, however."
+msgstr ""
+
+#: basic_mapping.xml:1873(para)
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:1878(para)
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr ""
+
+#: basic_mapping.xml:1887(title)
+msgid "one-to-one"
+msgstr ""
+
+#: basic_mapping.xml:1889(para)
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr ""
+
+#: basic_mapping.xml:1935(para)
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: basic_mapping.xml:1941(para)
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr ""
+
+#: basic_mapping.xml:1956(para)
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: basic_mapping.xml:1969(para)
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr ""
+
+#: basic_mapping.xml:1977(para)
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr ""
+
+#: basic_mapping.xml:1995(para)
+msgid "There are two varieties of one-to-one association:"
+msgstr ""
+
+#: basic_mapping.xml:1999(para)
+msgid "primary key associations"
+msgstr ""
+
+#: basic_mapping.xml:2002(para)
+msgid "unique foreign key associations"
+msgstr ""
+
+#: basic_mapping.xml:2007(para)
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr ""
+
+#: basic_mapping.xml:2014(para)
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr ""
+
+#: basic_mapping.xml:2022(para)
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr ""
+
+#: basic_mapping.xml:2040(para)
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr ""
+
+#: basic_mapping.xml:2046(para)
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr ""
+
+#: basic_mapping.xml:2053(para)
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr ""
+
+#: basic_mapping.xml:2063(title)
+msgid "natural-id"
+msgstr ""
+
+#: basic_mapping.xml:2071(para)
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr ""
+
+#: basic_mapping.xml:2080(para)
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr ""
+
+#: basic_mapping.xml:2085(para)
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr ""
+
+#: basic_mapping.xml:2091(para)
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr ""
+
+#: basic_mapping.xml:2101(title)
+msgid "component, dynamic-component"
+msgstr ""
+
+#: basic_mapping.xml:2103(para)
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr ""
+
+#: basic_mapping.xml:2144(para)
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr ""
+
+#: basic_mapping.xml:2150(para) basic_mapping.xml:2250(para)
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr ""
+
+#: basic_mapping.xml:2156(para) basic_mapping.xml:2256(para)
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr ""
+
+#: basic_mapping.xml:2168(para)
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: basic_mapping.xml:2175(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: basic_mapping.xml:2183(para) basic_mapping.xml:2270(para)
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr ""
+
+#: basic_mapping.xml:2192(para)
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr ""
+
+#: basic_mapping.xml:2197(para)
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: basic_mapping.xml:2203(para)
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr ""
+
+#: basic_mapping.xml:2212(title)
+msgid "properties"
+msgstr ""
+
+#: basic_mapping.xml:2214(para)
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr ""
+
+#: basic_mapping.xml:2244(para)
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr ""
+
+#: basic_mapping.xml:2262(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr ""
+
+#: basic_mapping.xml:2279(para)
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr ""
+
+#: basic_mapping.xml:2294(para)
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr ""
+
+#: basic_mapping.xml:2306(para)
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr ""
+
+#: basic_mapping.xml:2314(title)
+msgid "subclass"
+msgstr ""
+
+#: basic_mapping.xml:2316(para)
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr ""
+
+#: basic_mapping.xml:2345(para) basic_mapping.xml:2422(para) basic_mapping.xml:2533(para)
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr ""
+
+#: basic_mapping.xml:2350(para)
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr ""
+
+#: basic_mapping.xml:2356(para) basic_mapping.xml:2432(para) basic_mapping.xml:2543(para)
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr ""
+
+#: basic_mapping.xml:2362(para) basic_mapping.xml:2438(para) basic_mapping.xml:2549(para)
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr ""
+
+#: basic_mapping.xml:2370(para)
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+
+#: basic_mapping.xml:2378(para) basic_mapping.xml:2485(para) basic_mapping.xml:2561(para)
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr ""
+
+#: basic_mapping.xml:2385(title)
+msgid "joined-subclass"
+msgstr ""
+
+#: basic_mapping.xml:2387(para)
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr ""
+
+#: basic_mapping.xml:2427(para) basic_mapping.xml:2538(para)
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr ""
+
+#: basic_mapping.xml:2446(para)
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr ""
+
+#: basic_mapping.xml:2492(title)
+msgid "union-subclass"
+msgstr ""
+
+#: basic_mapping.xml:2494(para)
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr ""
+
+#: basic_mapping.xml:2557(para)
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr ""
+
+#: basic_mapping.xml:2568(title)
+msgid "join"
+msgstr ""
+
+#: basic_mapping.xml:2570(para)
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr ""
+
+#: basic_mapping.xml:2600(para)
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr ""
+
+#: basic_mapping.xml:2617(para)
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr ""
+
+#: basic_mapping.xml:2630(para)
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr ""
+
+#: basic_mapping.xml:2637(para)
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr ""
+
+#: basic_mapping.xml:2646(para)
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr ""
+
+#: basic_mapping.xml:2664(para)
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr ""
+
+#: basic_mapping.xml:2674(title)
+msgid "key"
+msgstr ""
+
+#: basic_mapping.xml:2676(para)
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr ""
+
+#: basic_mapping.xml:2710(para)
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr ""
+
+#: basic_mapping.xml:2717(para)
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr ""
+
+#: basic_mapping.xml:2724(para)
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: basic_mapping.xml:2731(para)
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: basic_mapping.xml:2738(para)
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr ""
+
+#: basic_mapping.xml:2746(para)
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr ""
+
+#: basic_mapping.xml:2754(para)
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr ""
+
+#: basic_mapping.xml:2764(title)
+msgid "column and formula elements"
+msgstr ""
+
+#: basic_mapping.xml:2765(para)
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr ""
+
+#: basic_mapping.xml:2786(para)
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr ""
+
+#: basic_mapping.xml:2801(title)
+msgid "import"
+msgstr ""
+
+#: basic_mapping.xml:2803(para)
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr ""
+
+#: basic_mapping.xml:2823(para)
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr ""
+
+#: basic_mapping.xml:2828(para)
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr ""
+
+#: basic_mapping.xml:2839(title)
+msgid "any"
+msgstr ""
+
+#: basic_mapping.xml:2841(para)
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr ""
+
+#: basic_mapping.xml:2851(para)
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr ""
+
+#: basic_mapping.xml:2892(para)
+msgid "<literal>name</literal>: the property name."
+msgstr ""
+
+#: basic_mapping.xml:2897(para)
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr ""
+
+#: basic_mapping.xml:2902(para)
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr ""
+
+#: basic_mapping.xml:2908(para)
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr ""
+
+#: basic_mapping.xml:2920(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr ""
+
+#: basic_mapping.xml:2935(title)
+msgid "Hibernate Types"
+msgstr ""
+
+#: basic_mapping.xml:2938(title)
+msgid "Entities and values"
+msgstr ""
+
+#: basic_mapping.xml:2940(para)
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr ""
+
+#: basic_mapping.xml:2945(para)
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr ""
+
+#: basic_mapping.xml:2956(para)
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr ""
+
+#: basic_mapping.xml:2967(para)
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr ""
+
+#: basic_mapping.xml:2981(para)
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr ""
+
+#: basic_mapping.xml:2985(para)
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr ""
+
+#: basic_mapping.xml:2998(para)
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr ""
+
+#: basic_mapping.xml:3005(title)
+msgid "Basic value types"
+msgstr ""
+
+#: basic_mapping.xml:3012(literal)
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr ""
+
+#: basic_mapping.xml:3015(para)
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr ""
+
+#: basic_mapping.xml:3024(literal)
+msgid "string"
+msgstr ""
+
+#: basic_mapping.xml:3026(para)
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:3033(literal)
+msgid "date, time, timestamp"
+msgstr ""
+
+#: basic_mapping.xml:3035(para)
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr ""
+
+#: basic_mapping.xml:3043(literal)
+msgid "calendar, calendar_date"
+msgstr ""
+
+#: basic_mapping.xml:3045(para)
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr ""
+
+#: basic_mapping.xml:3053(literal)
+msgid "big_decimal, big_integer"
+msgstr ""
+
+#: basic_mapping.xml:3055(para)
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr ""
+
+#: basic_mapping.xml:3063(literal)
+msgid "locale, timezone, currency"
+msgstr ""
+
+#: basic_mapping.xml:3065(para)
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+
+#: basic_mapping.xml:3079(para)
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr ""
+
+#: basic_mapping.xml:3087(literal)
+msgid "binary"
+msgstr ""
+
+#: basic_mapping.xml:3089(para)
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr ""
+
+#: basic_mapping.xml:3095(literal)
+msgid "text"
+msgstr ""
+
+#: basic_mapping.xml:3097(para)
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr ""
+
+#: basic_mapping.xml:3104(literal)
+msgid "serializable"
+msgstr ""
+
+#: basic_mapping.xml:3106(para)
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr ""
+
+#: basic_mapping.xml:3115(literal)
+msgid "clob, blob"
+msgstr ""
+
+#: basic_mapping.xml:3117(para)
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr ""
+
+#: basic_mapping.xml:3127(literal)
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr ""
+
+#: basic_mapping.xml:3131(para)
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr ""
+
+#: basic_mapping.xml:3007(para)
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into <placeholder-1/>"
+msgstr ""
+
+#: basic_mapping.xml:3146(para)
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr ""
+
+#: basic_mapping.xml:3152(para)
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr ""
+
+#: basic_mapping.xml:3161(title)
+msgid "Custom value types"
+msgstr ""
+
+#: basic_mapping.xml:3163(para)
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr ""
+
+#: basic_mapping.xml:3174(para)
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr ""
+
+#: basic_mapping.xml:3187(para)
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr ""
+
+#: basic_mapping.xml:3192(para)
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr ""
+
+#: basic_mapping.xml:3198(para)
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr ""
+
+#: basic_mapping.xml:3212(para)
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr ""
+
+#: basic_mapping.xml:3217(para)
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr ""
+
+#: basic_mapping.xml:3230(para)
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr ""
+
+#: basic_mapping.xml:3235(para)
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr ""
+
+#: basic_mapping.xml:3251(title)
+msgid "Mapping a class more than once"
+msgstr ""
+
+#: basic_mapping.xml:3252(para)
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr ""
+
+#: basic_mapping.xml:3278(para)
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr ""
+
+#: basic_mapping.xml:3286(title)
+msgid "SQL quoted identifiers"
+msgstr ""
+
+#: basic_mapping.xml:3287(para)
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr ""
+
+#: basic_mapping.xml:3304(title)
+msgid "Metadata alternatives"
+msgstr ""
+
+#: basic_mapping.xml:3306(para)
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: basic_mapping.xml:3311(title)
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: basic_mapping.xml:3313(para)
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: basic_mapping.xml:3425(para)
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: basic_mapping.xml:3432(title)
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: basic_mapping.xml:3434(para)
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: basic_mapping.xml:3445(para)
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: basic_mapping.xml:3472(para)
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: basic_mapping.xml:3481(title)
+msgid "Generated Properties"
+msgstr ""
+
+#: basic_mapping.xml:3482(para)
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: basic_mapping.xml:3491(para)
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\">versions</xref>, <xref linkend=\"mapping-declaration-timestamp\">timestamps</xref>, and <xref linkend=\"mapping-declaration-property\">simple properties</xref> can be marked as generated."
+msgstr ""
+
+#: basic_mapping.xml:3498(para)
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: basic_mapping.xml:3502(para)
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\">version</xref> and <xref linkend=\"mapping-declaration-timestamp\">timestamp</xref> properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: basic_mapping.xml:3510(para)
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: basic_mapping.xml:3517(title)
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: basic_mapping.xml:3518(para)
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: basic_mapping.xml:3527(para)
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: basic_mapping.xml:3538(para)
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: basic_mapping.xml:3549(para)
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: basic_mapping.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/batch.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/batch.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/batch.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,152 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:29-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: batch.xml:5(title)
+msgid "Batch processing"
+msgstr ""
+
+#: batch.xml:7(para)
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr ""
+
+#: batch.xml:21(para)
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr ""
+
+#: batch.xml:27(para)
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr ""
+
+#: batch.xml:36(para)
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr ""
+
+#: batch.xml:41(para)
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr ""
+
+#: batch.xml:48(para)
+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 ""
+
+#: batch.xml:54(title)
+msgid "Batch inserts"
+msgstr ""
+
+#: batch.xml:56(para)
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr ""
+
+#: batch.xml:81(title)
+msgid "Batch updates"
+msgstr ""
+
+#: batch.xml:83(para)
+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 ""
+
+#: batch.xml:112(title)
+msgid "The StatelessSession interface"
+msgstr ""
+
+#: batch.xml:113(para)
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr ""
+
+#: batch.xml:142(para)
+msgid "Note that 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 ""
+
+#: batch.xml:148(para)
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr ""
+
+#: batch.xml:161(title)
+msgid "DML-style operations"
+msgstr ""
+
+#: batch.xml:163(para)
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\">HQL</xref>)."
+msgstr ""
+
+#: batch.xml:173(para)
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr ""
+
+#: batch.xml:181(para)
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr ""
+
+#: batch.xml:186(para)
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 ""
+
+#: batch.xml:194(para)
+msgid "No <xref linkend=\"queryhql-joins-forms\">joins</xref> (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr ""
+
+#: batch.xml:201(para)
+msgid "The where-clause is also optional."
+msgstr ""
+
+#: batch.xml:207(para)
+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 ""
+
+#: batch.xml:225(para)
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\">version</xref> or the <xref linkend=\"mapping-declaration-timestamp\">timestamp</xref> property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 ""
+
+#: batch.xml:245(para)
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr ""
+
+#: batch.xml:250(para)
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr ""
+
+#: batch.xml:266(para)
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr ""
+
+#: batch.xml:277(para)
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr ""
+
+#: batch.xml:285(para)
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr ""
+
+#: batch.xml:288(para)
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 ""
+
+#: batch.xml:298(para)
+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. Note however that this might 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 ""
+
+#: batch.xml:310(para)
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ""
+
+#: batch.xml:325(para)
+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 ""
+
+#: batch.xml:335(para)
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: batch.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/best_practices.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/best_practices.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/best_practices.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,172 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:29-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: best_practices.xml:5(title)
+msgid "Best Practices"
+msgstr ""
+
+#: best_practices.xml:9(term)
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr ""
+
+#: best_practices.xml:11(para)
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr ""
+
+#: best_practices.xml:19(term)
+msgid "Declare identifier properties on persistent classes."
+msgstr ""
+
+#: best_practices.xml:21(para)
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr ""
+
+#: best_practices.xml:29(term)
+msgid "Identify natural keys."
+msgstr ""
+
+#: best_practices.xml:31(para)
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr ""
+
+#: best_practices.xml:39(term)
+msgid "Place each class mapping in its own file."
+msgstr ""
+
+#: best_practices.xml:41(para)
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr ""
+
+#: best_practices.xml:49(term)
+msgid "Load mappings as resources."
+msgstr ""
+
+#: best_practices.xml:51(para)
+msgid "Deploy the mappings along with the classes they map."
+msgstr ""
+
+#: best_practices.xml:57(term)
+msgid "Consider externalising query strings."
+msgstr ""
+
+#: best_practices.xml:59(para)
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr ""
+
+#: best_practices.xml:67(term)
+msgid "Use bind variables."
+msgstr ""
+
+#: best_practices.xml:69(para)
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr ""
+
+#: best_practices.xml:77(term)
+msgid "Don't manage your own JDBC connections."
+msgstr ""
+
+#: best_practices.xml:79(para)
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr ""
+
+#: best_practices.xml:87(term)
+msgid "Consider using a custom type."
+msgstr ""
+
+#: best_practices.xml:89(para)
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr ""
+
+#: best_practices.xml:98(term)
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr ""
+
+#: best_practices.xml:100(para)
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr ""
+
+#: best_practices.xml:110(term)
+msgid "Understand <literal>Session</literal> flushing."
+msgstr ""
+
+#: best_practices.xml:112(para)
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr ""
+
+#: best_practices.xml:121(term)
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr ""
+
+#: best_practices.xml:123(para)
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr ""
+
+#: best_practices.xml:132(term)
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr ""
+
+#: best_practices.xml:134(para)
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr ""
+
+#: best_practices.xml:148(term)
+msgid "Don't treat exceptions as recoverable."
+msgstr ""
+
+#: best_practices.xml:150(para)
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr ""
+
+#: best_practices.xml:160(term)
+msgid "Prefer lazy fetching for associations."
+msgstr ""
+
+#: best_practices.xml:162(para)
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr ""
+
+#: best_practices.xml:172(term)
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr ""
+
+#: best_practices.xml:177(para)
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr ""
+
+#: best_practices.xml:191(term)
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr ""
+
+#: best_practices.xml:193(para)
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr ""
+
+#: best_practices.xml:203(term)
+msgid "Don't use exotic association mappings."
+msgstr ""
+
+#: best_practices.xml:205(para)
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr ""
+
+#: best_practices.xml:215(term)
+msgid "Prefer bidirectional associations."
+msgstr ""
+
+#: best_practices.xml:217(para)
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: best_practices.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/collection_mapping.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/collection_mapping.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/collection_mapping.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,492 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:30-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: collection_mapping.xml:5(title)
+msgid "Collection Mapping"
+msgstr ""
+
+#: collection_mapping.xml:8(title)
+msgid "Persistent collections"
+msgstr ""
+
+#: collection_mapping.xml:10(para)
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr ""
+
+#: collection_mapping.xml:25(para)
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr ""
+
+#: collection_mapping.xml:34(para)
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr ""
+
+#: collection_mapping.xml:54(para)
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr ""
+
+#: collection_mapping.xml:61(para)
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr ""
+
+#: collection_mapping.xml:72(para)
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr ""
+
+#: collection_mapping.xml:81(title)
+msgid "Collection mappings"
+msgstr ""
+
+#: collection_mapping.xml:83(para)
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr ""
+
+#: collection_mapping.xml:97(para)
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr ""
+
+#: collection_mapping.xml:147(para)
+msgid "<literal>name</literal> the collection property name"
+msgstr ""
+
+#: collection_mapping.xml:152(para)
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr ""
+
+#: collection_mapping.xml:158(para)
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr ""
+
+#: collection_mapping.xml:164(para)
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr ""
+
+#: collection_mapping.xml:173(para)
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr ""
+
+#: collection_mapping.xml:179(para)
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr ""
+
+#: collection_mapping.xml:185(para)
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr ""
+
+#: collection_mapping.xml:191(para)
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr ""
+
+#: collection_mapping.xml:198(para)
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr ""
+
+#: collection_mapping.xml:205(para)
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr ""
+
+#: collection_mapping.xml:212(para)
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr ""
+
+#: collection_mapping.xml:218(para)
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr ""
+
+#: collection_mapping.xml:224(para)
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr ""
+
+#: collection_mapping.xml:232(para)
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr ""
+
+#: collection_mapping.xml:242(title)
+msgid "Collection foreign keys"
+msgstr ""
+
+#: collection_mapping.xml:244(para)
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr ""
+
+#: collection_mapping.xml:252(para)
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr ""
+
+#: collection_mapping.xml:261(para)
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr ""
+
+#: collection_mapping.xml:267(para)
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr ""
+
+#: collection_mapping.xml:275(title)
+msgid "Collection elements"
+msgstr ""
+
+#: collection_mapping.xml:277(para)
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr ""
+
+#: collection_mapping.xml:286(para)
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr ""
+
+#: collection_mapping.xml:298(title)
+msgid "Indexed collections"
+msgstr ""
+
+#: collection_mapping.xml:300(para)
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr ""
+
+#: collection_mapping.xml:323(para)
+msgid "<literal>column_name</literal> (required): The name of the column holding the collection index values."
+msgstr ""
+
+#: collection_mapping.xml:329(para)
+msgid "<literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array."
+msgstr ""
+
+#: collection_mapping.xml:351(para)
+msgid "<literal>column</literal> (optional): The name of the column holding the collection index values."
+msgstr ""
+
+#: collection_mapping.xml:357(para)
+msgid "<literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map."
+msgstr ""
+
+#: collection_mapping.xml:363(para)
+msgid "<literal>type</literal> (reguired): The type of the map keys."
+msgstr ""
+
+#: collection_mapping.xml:383(para)
+msgid "<literal>column</literal> (optional): The name of the foreign key column for the collection index values."
+msgstr ""
+
+#: collection_mapping.xml:389(para)
+msgid "<literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key."
+msgstr ""
+
+#: collection_mapping.xml:395(para)
+msgid "<literal>class</literal> (required): The entity class used as the map key."
+msgstr ""
+
+#: collection_mapping.xml:403(para)
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr ""
+
+#: collection_mapping.xml:412(para)
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr ""
+
+#: collection_mapping.xml:419(title)
+msgid "Collections of values and many-to-many associations"
+msgstr ""
+
+#: collection_mapping.xml:421(para)
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr ""
+
+#: collection_mapping.xml:428(para)
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr ""
+
+#: collection_mapping.xml:451(para)
+msgid "<literal>column</literal> (optional): The name of the column holding the collection element values."
+msgstr ""
+
+#: collection_mapping.xml:457(para)
+msgid "<literal>formula</literal> (optional): An SQL formula used to evaluate the element."
+msgstr ""
+
+#: collection_mapping.xml:463(para)
+msgid "<literal>type</literal> (required): The type of the collection element."
+msgstr ""
+
+#: collection_mapping.xml:470(para)
+msgid "A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element."
+msgstr ""
+
+#: collection_mapping.xml:500(para)
+msgid "<literal>column</literal> (optional): The name of the element foreign key column."
+msgstr ""
+
+#: collection_mapping.xml:505(para)
+msgid "<literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value."
+msgstr ""
+
+#: collection_mapping.xml:511(para) collection_mapping.xml:665(para)
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr ""
+
+#: collection_mapping.xml:516(para)
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal> nested element."
+msgstr ""
+
+#: collection_mapping.xml:527(para)
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many."
+msgstr ""
+
+#: collection_mapping.xml:534(para)
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: collection_mapping.xml:541(para) collection_mapping.xml:677(para)
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr ""
+
+#: collection_mapping.xml:547(para)
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: collection_mapping.xml:556(para)
+msgid "Some examples, first, a set of strings:"
+msgstr ""
+
+#: collection_mapping.xml:565(para)
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr ""
+
+#: collection_mapping.xml:577(para)
+msgid "An array of entities - in this case, a many to many association:"
+msgstr ""
+
+#: collection_mapping.xml:589(para)
+msgid "A map from string indices to dates:"
+msgstr ""
+
+#: collection_mapping.xml:602(para)
+msgid "A list of components (discussed in the next chapter):"
+msgstr ""
+
+#: collection_mapping.xml:620(title)
+msgid "One-to-many associations"
+msgstr ""
+
+#: collection_mapping.xml:622(para)
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr ""
+
+#: collection_mapping.xml:630(para)
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr ""
+
+#: collection_mapping.xml:636(para)
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr ""
+
+#: collection_mapping.xml:643(para)
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr ""
+
+#: collection_mapping.xml:670(para)
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: collection_mapping.xml:685(para)
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr ""
+
+#: collection_mapping.xml:691(para)
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr ""
+
+#: collection_mapping.xml:700(para)
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr ""
+
+#: collection_mapping.xml:717(title)
+msgid "Advanced collection mappings"
+msgstr ""
+
+#: collection_mapping.xml:720(title)
+msgid "Sorted collections"
+msgstr ""
+
+#: collection_mapping.xml:722(para)
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr ""
+
+#: collection_mapping.xml:740(para)
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr ""
+
+#: collection_mapping.xml:746(para)
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr ""
+
+#: collection_mapping.xml:751(para)
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr ""
+
+#: collection_mapping.xml:771(para)
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr ""
+
+#: collection_mapping.xml:776(para)
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr ""
+
+#: collection_mapping.xml:786(title)
+msgid "Bidirectional associations"
+msgstr ""
+
+#: collection_mapping.xml:795(term)
+msgid "one-to-many"
+msgstr ""
+
+#: collection_mapping.xml:797(para)
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr ""
+
+#: collection_mapping.xml:803(term)
+msgid "many-to-many"
+msgstr ""
+
+#: collection_mapping.xml:805(para)
+msgid "set or bag valued at both ends"
+msgstr ""
+
+#: collection_mapping.xml:788(para)
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported: <placeholder-1/>"
+msgstr ""
+
+#: collection_mapping.xml:814(para)
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr ""
+
+#: collection_mapping.xml:821(para)
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr ""
+
+#: collection_mapping.xml:846(para)
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr ""
+
+#: collection_mapping.xml:861(para)
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr ""
+
+#: collection_mapping.xml:865(para)
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: collection_mapping.xml:889(para)
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr ""
+
+#: collection_mapping.xml:897(title)
+msgid "Bidirectional associations with indexed collections"
+msgstr ""
+
+#: collection_mapping.xml:898(para)
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr ""
+
+#: collection_mapping.xml:927(para)
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr ""
+
+#: collection_mapping.xml:957(para)
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr ""
+
+#: collection_mapping.xml:965(title)
+msgid "Ternary associations"
+msgstr ""
+
+#: collection_mapping.xml:967(para)
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr ""
+
+#: collection_mapping.xml:984(para)
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr ""
+
+#: collection_mapping.xml:989(para)
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr ""
+
+#: collection_mapping.xml:996(literal)
+msgid "Using an <idbag>"
+msgstr ""
+
+#: collection_mapping.xml:998(para)
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr ""
+
+#: collection_mapping.xml:1009(para)
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr ""
+
+#: collection_mapping.xml:1022(para)
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr ""
+
+#: collection_mapping.xml:1029(para)
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr ""
+
+#: collection_mapping.xml:1036(para)
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr ""
+
+#: collection_mapping.xml:1060(title)
+msgid "Collection examples"
+msgstr ""
+
+#: collection_mapping.xml:1062(para)
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr ""
+
+#: collection_mapping.xml:1084(para)
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr ""
+
+#: collection_mapping.xml:1111(para)
+msgid "This maps to the following table definitions:"
+msgstr ""
+
+#: collection_mapping.xml:1119(para)
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr ""
+
+#: collection_mapping.xml:1146(para)
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr ""
+
+#: collection_mapping.xml:1157(para)
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr ""
+
+#: collection_mapping.xml:1184(para)
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr ""
+
+#: collection_mapping.xml:1210(para)
+msgid "Table definitions:"
+msgstr ""
+
+#: collection_mapping.xml:1222(para)
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr ""
+
+#: collection_mapping.xml:1227(para)
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: collection_mapping.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/component_mapping.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/component_mapping.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/component_mapping.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,164 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:30-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: component_mapping.xml:5(title)
+msgid "Component Mapping"
+msgstr ""
+
+#: component_mapping.xml:7(para)
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr ""
+
+#: component_mapping.xml:13(title)
+msgid "Dependent objects"
+msgstr ""
+
+#: component_mapping.xml:15(para)
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr ""
+
+#: component_mapping.xml:71(para)
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr ""
+
+#: component_mapping.xml:78(para)
+msgid "Our Hibernate mapping would look like:"
+msgstr ""
+
+#: component_mapping.xml:94(para)
+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 ""
+
+#: component_mapping.xml:102(para)
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr ""
+
+#: component_mapping.xml:111(para)
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr ""
+
+#: component_mapping.xml:118(para)
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: component_mapping.xml:140(title)
+msgid "Collections of dependent objects"
+msgstr ""
+
+#: component_mapping.xml:142(para)
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr ""
+
+#: component_mapping.xml:158(para)
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr ""
+
+#: component_mapping.xml:164(para)
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr ""
+
+#: component_mapping.xml:176(para)
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr ""
+
+#: component_mapping.xml:187(para)
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 ""
+
+#: component_mapping.xml:210(para)
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr ""
+
+#: component_mapping.xml:218(para)
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr ""
+
+#: component_mapping.xml:231(para)
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr ""
+
+#: component_mapping.xml:239(title)
+msgid "Components as Map indices"
+msgstr ""
+
+#: component_mapping.xml:241(para)
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr ""
+
+#: component_mapping.xml:250(title)
+msgid "Components as composite identifiers"
+msgstr ""
+
+#: component_mapping.xml:252(para)
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr ""
+
+#: component_mapping.xml:259(para)
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr ""
+
+#: component_mapping.xml:264(para)
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr ""
+
+#: component_mapping.xml:273(emphasis)
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr ""
+
+#: component_mapping.xml:277(para)
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr ""
+
+#: component_mapping.xml:282(para)
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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 ""
+
+#: component_mapping.xml:309(para)
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr ""
+
+#: component_mapping.xml:322(para)
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr ""
+
+#: component_mapping.xml:327(para)
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr ""
+
+#: component_mapping.xml:341(para)
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr ""
+
+#: component_mapping.xml:354(para)
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr ""
+
+#: component_mapping.xml:358(para)
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr ""
+
+#: component_mapping.xml:382(title)
+msgid "Dynamic components"
+msgstr ""
+
+#: component_mapping.xml:384(para)
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr ""
+
+#: component_mapping.xml:394(para)
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: component_mapping.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/configuration.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/configuration.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/configuration.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1470 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:31-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: configuration.xml:5(title)
+msgid "Configuration"
+msgstr ""
+
+#: configuration.xml:7(para)
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr ""
+
+#: configuration.xml:16(title)
+msgid "Programmatic configuration"
+msgstr ""
+
+#: configuration.xml:18(para)
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr ""
+
+#: configuration.xml:26(para)
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr ""
+
+#: configuration.xml:36(para)
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr ""
+
+#: configuration.xml:45(para)
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr ""
+
+#: configuration.xml:52(para)
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr ""
+
+#: configuration.xml:64(para)
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr ""
+
+#: configuration.xml:71(para)
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr ""
+
+#: configuration.xml:77(para)
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr ""
+
+#: configuration.xml:83(para)
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr ""
+
+#: configuration.xml:89(para)
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr ""
+
+#: configuration.xml:96(para)
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr ""
+
+#: configuration.xml:101(para)
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr ""
+
+#: configuration.xml:109(title)
+msgid "Obtaining a SessionFactory"
+msgstr ""
+
+#: configuration.xml:111(para)
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr ""
+
+#: configuration.xml:119(para)
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr ""
+
+#: configuration.xml:128(title)
+msgid "JDBC connections"
+msgstr ""
+
+#: configuration.xml:130(para)
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr ""
+
+#: configuration.xml:138(para)
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr ""
+
+#: configuration.xml:143(para)
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr ""
+
+#: configuration.xml:150(para)
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr ""
+
+#: configuration.xml:156(title)
+msgid "Hibernate JDBC Properties"
+msgstr ""
+
+#: configuration.xml:162(entry) configuration.xml:258(entry) configuration.xml:360(entry) configuration.xml:551(entry) configuration.xml:747(entry) configuration.xml:854(entry) configuration.xml:942(entry)
+msgid "Property name"
+msgstr ""
+
+#: configuration.xml:163(entry) configuration.xml:259(entry) configuration.xml:361(entry) configuration.xml:552(entry) configuration.xml:748(entry) configuration.xml:855(entry) configuration.xml:943(entry)
+msgid "Purpose"
+msgstr ""
+
+#: configuration.xml:169(literal)
+msgid "hibernate.connection.driver_class"
+msgstr ""
+
+#: configuration.xml:172(emphasis)
+msgid "JDBC driver class"
+msgstr ""
+
+#: configuration.xml:177(literal)
+msgid "hibernate.connection.url"
+msgstr ""
+
+#: configuration.xml:180(emphasis)
+msgid "JDBC URL"
+msgstr ""
+
+#: configuration.xml:185(literal) configuration.xml:289(literal)
+msgid "hibernate.connection.username"
+msgstr ""
+
+#: configuration.xml:188(emphasis) configuration.xml:292(emphasis)
+msgid "database user"
+msgstr ""
+
+#: configuration.xml:193(literal) configuration.xml:297(literal)
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: configuration.xml:196(emphasis) configuration.xml:300(emphasis)
+msgid "database user password"
+msgstr ""
+
+#: configuration.xml:201(literal)
+msgid "hibernate.connection.pool_size"
+msgstr ""
+
+#: configuration.xml:204(emphasis)
+msgid "maximum number of pooled connections"
+msgstr ""
+
+#: configuration.xml:211(para)
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr ""
+
+#: configuration.xml:221(para)
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr ""
+
+#: configuration.xml:230(para)
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr ""
+
+#: configuration.xml:244(para)
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr ""
+
+#: configuration.xml:252(title)
+msgid "Hibernate Datasource Properties"
+msgstr ""
+
+#: configuration.xml:265(literal)
+msgid "hibernate.connection.datasource"
+msgstr ""
+
+#: configuration.xml:268(emphasis)
+msgid "datasource JNDI name"
+msgstr ""
+
+#: configuration.xml:273(literal)
+msgid "hibernate.jndi.url"
+msgstr ""
+
+#: configuration.xml:276(emphasis)
+msgid "URL of the JNDI provider"
+msgstr ""
+
+#: configuration.xml:275(entry) configuration.xml:283(entry) configuration.xml:291(entry) configuration.xml:299(entry)
+msgid "<placeholder-1/> (optional)"
+msgstr ""
+
+#: configuration.xml:281(literal)
+msgid "hibernate.jndi.class"
+msgstr ""
+
+#: configuration.xml:284(literal) configuration.xml:733(literal)
+msgid "InitialContextFactory"
+msgstr ""
+
+#: configuration.xml:284(emphasis)
+msgid "class of the JNDI <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:307(para)
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr ""
+
+#: configuration.xml:319(para)
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr ""
+
+#: configuration.xml:324(para)
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr ""
+
+#: configuration.xml:330(para)
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr ""
+
+#: configuration.xml:339(title)
+msgid "Optional configuration properties"
+msgstr ""
+
+#: configuration.xml:341(para)
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr ""
+
+#: configuration.xml:346(para)
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr ""
+
+#: configuration.xml:354(title)
+msgid "Hibernate Configuration Properties"
+msgstr ""
+
+#: configuration.xml:367(literal)
+msgid "hibernate.dialect"
+msgstr ""
+
+#: configuration.xml:370(literal) configuration.xml:1045(entry)
+msgid "Dialect"
+msgstr ""
+
+#: configuration.xml:374(emphasis) configuration.xml:413(emphasis) configuration.xml:426(emphasis) configuration.xml:439(emphasis) configuration.xml:600(emphasis) configuration.xml:644(emphasis) configuration.xml:657(emphasis) configuration.xml:671(emphasis) configuration.xml:759(emphasis) configuration.xml:774(emphasis) configuration.xml:786(emphasis) configuration.xml:800(emphasis) configuration.xml:813(emphasis) configuration.xml:825(emphasis) configuration.xml:838(emphasis) configuration.xml:868(emphasis) configuration.xml:882(emphasis) configuration.xml:896(emphasis) configuration.xml:984(emphasis)
+msgid "eg."
+msgstr ""
+
+#: configuration.xml:375(literal)
+msgid "full.classname.of.Dialect"
+msgstr ""
+
+#: configuration.xml:369(entry)
+msgid "The classname of a Hibernate <placeholder-1/> which allows Hibernate to generate SQL optimized for a particular relational database. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:381(literal)
+msgid "hibernate.show_sql"
+msgstr ""
+
+#: configuration.xml:385(literal) configuration.xml:1247(literal)
+msgid "org.hibernate.SQL"
+msgstr ""
+
+#: configuration.xml:386(literal)
+msgid "debug"
+msgstr ""
+
+#: configuration.xml:387(para) configuration.xml:399(para) configuration.xml:493(para) configuration.xml:506(para) configuration.xml:519(para) configuration.xml:532(para) configuration.xml:586(para) configuration.xml:613(para) configuration.xml:627(para) configuration.xml:682(para) configuration.xml:910(para) configuration.xml:925(para) configuration.xml:1015(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis><literal>true</literal> | <literal>false</literal>"
+msgstr ""
+
+#: configuration.xml:383(entry)
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <placeholder-1/> to <placeholder-2/>. <placeholder-3/>"
+msgstr ""
+
+#: configuration.xml:395(literal)
+msgid "hibernate.format_sql"
+msgstr ""
+
+#: configuration.xml:397(entry)
+msgid "Pretty print the SQL in the log and console. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:407(literal)
+msgid "hibernate.default_schema"
+msgstr ""
+
+#: configuration.xml:414(literal)
+msgid "SCHEMA_NAME"
+msgstr ""
+
+#: configuration.xml:409(entry)
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:420(literal)
+msgid "hibernate.default_catalog"
+msgstr ""
+
+#: configuration.xml:427(literal)
+msgid "CATALOG_NAME"
+msgstr ""
+
+#: configuration.xml:422(entry)
+msgid "Qualify unqualified table names with the given catalog in generated SQL. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:433(literal)
+msgid "hibernate.session_factory_name"
+msgstr ""
+
+#: configuration.xml:436(literal) configuration.xml:478(literal) configuration.xml:995(literal) configuration.xml:997(literal)
+msgid "SessionFactory"
+msgstr ""
+
+#: configuration.xml:440(literal) configuration.xml:883(literal)
+msgid "jndi/composite/name"
+msgstr ""
+
+#: configuration.xml:435(entry)
+msgid "The <placeholder-1/> will be automatically bound to this name in JNDI after it has been created. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:446(literal)
+msgid "hibernate.max_fetch_depth"
+msgstr ""
+
+#: configuration.xml:451(literal)
+msgid "0"
+msgstr ""
+
+#: configuration.xml:452(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr ""
+
+#: configuration.xml:448(entry)
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <placeholder-1/> disables default outer join fetching. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:461(literal)
+msgid "hibernate.default_batch_fetch_size"
+msgstr ""
+
+#: configuration.xml:465(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr ""
+
+#: configuration.xml:463(entry)
+msgid "Set a default size for Hibernate batch fetching of associations. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:474(literal)
+msgid "hibernate.default_entity_mode"
+msgstr ""
+
+#: configuration.xml:479(para)
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr ""
+
+#: configuration.xml:476(entry)
+msgid "Set a default mode for entity representation for all sessions opened from this <placeholder-1/><placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:487(literal)
+msgid "hibernate.order_updates"
+msgstr ""
+
+#: configuration.xml:489(entry)
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:501(literal)
+msgid "hibernate.generate_statistics"
+msgstr ""
+
+#: configuration.xml:503(entry)
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:514(literal)
+msgid "hibernate.use_identifier_rollback"
+msgstr ""
+
+#: configuration.xml:516(entry)
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:527(literal)
+msgid "hibernate.use_sql_comments"
+msgstr ""
+
+#: configuration.xml:531(literal) configuration.xml:585(literal)
+msgid "false"
+msgstr ""
+
+#: configuration.xml:529(entry)
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <placeholder-1/>. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:543(title)
+msgid "Hibernate JDBC and Connection Properties"
+msgstr ""
+
+#: configuration.xml:558(literal)
+msgid "hibernate.jdbc.fetch_size"
+msgstr ""
+
+#: configuration.xml:562(literal)
+msgid "Statement.setFetchSize()"
+msgstr ""
+
+#: configuration.xml:560(entry)
+msgid "A non-zero value determines the JDBC fetch size (calls <placeholder-1/>)."
+msgstr ""
+
+#: configuration.xml:567(literal)
+msgid "hibernate.jdbc.batch_size"
+msgstr ""
+
+#: configuration.xml:571(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr ""
+
+#: configuration.xml:569(entry)
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:579(literal)
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr ""
+
+#: configuration.xml:582(literal)
+msgid "true"
+msgstr ""
+
+#: configuration.xml:583(literal)
+msgid "executeBatch()"
+msgstr ""
+
+#: configuration.xml:581(entry)
+msgid "Set this property to <placeholder-1/> if your JDBC driver returns correct row counts from <placeholder-2/> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <placeholder-3/>. <placeholder-4/>"
+msgstr ""
+
+#: configuration.xml:594(literal)
+msgid "hibernate.jdbc.factory_class"
+msgstr ""
+
+#: configuration.xml:597(literal)
+msgid "Batcher"
+msgstr ""
+
+#: configuration.xml:601(literal)
+msgid "classname.of.BatcherFactory"
+msgstr ""
+
+#: configuration.xml:596(entry)
+msgid "Select a custom <placeholder-1/>. Most applications will not need this configuration property. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:607(literal)
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr ""
+
+#: configuration.xml:609(entry)
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:621(literal)
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr ""
+
+#: configuration.xml:624(literal)
+msgid "binary"
+msgstr ""
+
+#: configuration.xml:625(literal)
+msgid "serializable"
+msgstr ""
+
+#: configuration.xml:623(entry)
+msgid "Use streams when writing/reading <placeholder-1/> or <placeholder-2/> types to/from JDBC (system-level property). <placeholder-3/>"
+msgstr ""
+
+#: configuration.xml:635(literal)
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr ""
+
+#: configuration.xml:638(literal)
+msgid "PreparedStatement.getGeneratedKeys()"
+msgstr ""
+
+#: configuration.xml:645(literal) configuration.xml:775(literal) configuration.xml:787(literal) configuration.xml:801(literal) configuration.xml:839(literal)
+msgid "true|false"
+msgstr ""
+
+#: configuration.xml:637(entry)
+msgid "Enable use of JDBC3 <placeholder-1/> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:651(literal)
+msgid "hibernate.connection.provider_class"
+msgstr ""
+
+#: configuration.xml:654(literal)
+msgid "ConnectionProvider"
+msgstr ""
+
+#: configuration.xml:658(literal)
+msgid "classname.of.ConnectionProvider"
+msgstr ""
+
+#: configuration.xml:653(entry)
+msgid "The classname of a custom <placeholder-1/> which provides JDBC connections to Hibernate. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:664(literal)
+msgid "hibernate.connection.isolation"
+msgstr ""
+
+#: configuration.xml:668(literal)
+msgid "java.sql.Connection"
+msgstr ""
+
+#: configuration.xml:672(literal)
+msgid "1, 2, 4, 8"
+msgstr ""
+
+#: configuration.xml:666(entry)
+msgid "Set the JDBC transaction isolation level. Check <placeholder-1/> for meaningful values but note that most databases do not support all isolation levels. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:678(literal)
+msgid "hibernate.connection.autocommit"
+msgstr ""
+
+#: configuration.xml:680(entry)
+msgid "Enables autocommit for JDBC pooled connections (not recommended). <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:690(literal)
+msgid "hibernate.connection.release_mode"
+msgstr ""
+
+#: configuration.xml:696(literal) configuration.xml:700(literal)
+msgid "after_statement"
+msgstr ""
+
+#: configuration.xml:699(literal) configuration.xml:701(literal)
+msgid "after_transaction"
+msgstr ""
+
+#: configuration.xml:699(literal)
+msgid "auto"
+msgstr ""
+
+#: configuration.xml:703(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis><literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr ""
+
+#: configuration.xml:708(para)
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See <xref linkend=\"architecture-current-session\"/>"
+msgstr ""
+
+#: configuration.xml:692(entry)
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <placeholder-1/> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <placeholder-2/>. <placeholder-3/> will choose <placeholder-4/> for the JTA and CMT transaction strategies and <placeholder-5/> for the JDBC transaction strategy. <placeholder-6/><placeholder-7/>"
+msgstr ""
+
+#: configuration.xml:720(emphasis) configuration.xml:729(emphasis)
+msgid "<propertyName>"
+msgstr ""
+
+#: configuration.xml:720(literal)
+msgid "hibernate.connection.<placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:723(literal) configuration.xml:732(literal)
+msgid "propertyName"
+msgstr ""
+
+#: configuration.xml:724(literal)
+msgid "DriverManager.getConnection()"
+msgstr ""
+
+#: configuration.xml:722(entry)
+msgid "Pass the JDBC property <placeholder-1/> to <placeholder-2/>."
+msgstr ""
+
+#: configuration.xml:729(literal)
+msgid "hibernate.jndi.<placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:731(entry)
+msgid "Pass the property <placeholder-1/> to the JNDI <placeholder-2/>."
+msgstr ""
+
+#: configuration.xml:741(title)
+msgid "Hibernate Cache Properties"
+msgstr ""
+
+#: configuration.xml:754(literal)
+msgid "hibernate.cache.provider_class"
+msgstr ""
+
+#: configuration.xml:757(literal)
+msgid "CacheProvider"
+msgstr ""
+
+#: configuration.xml:760(literal)
+msgid "classname.of.CacheProvider"
+msgstr ""
+
+#: configuration.xml:756(entry)
+msgid "The classname of a custom <placeholder-1/>. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:766(literal)
+msgid "hibernate.cache.use_minimal_puts"
+msgstr ""
+
+#: configuration.xml:768(entry)
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:781(literal)
+msgid "hibernate.cache.use_query_cache"
+msgstr ""
+
+#: configuration.xml:783(entry)
+msgid "Enable the query cache, individual queries still have to be set cachable. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:793(literal)
+msgid "hibernate.cache.use_second_level_cache"
+msgstr ""
+
+#: configuration.xml:797(literal)
+msgid "<cache>"
+msgstr ""
+
+#: configuration.xml:795(entry)
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <placeholder-1/> mapping. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:807(literal)
+msgid "hibernate.cache.query_cache_factory"
+msgstr ""
+
+#: configuration.xml:810(literal)
+msgid "QueryCache"
+msgstr ""
+
+#: configuration.xml:811(literal)
+msgid "StandardQueryCache"
+msgstr ""
+
+#: configuration.xml:814(literal)
+msgid "classname.of.QueryCache"
+msgstr ""
+
+#: configuration.xml:809(entry)
+msgid "The classname of a custom <placeholder-1/> interface, defaults to the built-in <placeholder-2/>. <placeholder-3/>"
+msgstr ""
+
+#: configuration.xml:820(literal)
+msgid "hibernate.cache.region_prefix"
+msgstr ""
+
+#: configuration.xml:826(literal)
+msgid "prefix"
+msgstr ""
+
+#: configuration.xml:822(entry)
+msgid "A prefix to use for second-level cache region names. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:832(literal)
+msgid "hibernate.cache.use_structured_entries"
+msgstr ""
+
+#: configuration.xml:834(entry)
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:848(title)
+msgid "Hibernate Transaction Properties"
+msgstr ""
+
+#: configuration.xml:861(literal)
+msgid "hibernate.transaction.factory_class"
+msgstr ""
+
+#: configuration.xml:864(literal)
+msgid "TransactionFactory"
+msgstr ""
+
+#: configuration.xml:865(literal)
+msgid "Transaction"
+msgstr ""
+
+#: configuration.xml:866(literal)
+msgid "JDBCTransactionFactory"
+msgstr ""
+
+#: configuration.xml:869(literal)
+msgid "classname.of.TransactionFactory"
+msgstr ""
+
+#: configuration.xml:863(entry)
+msgid "The classname of a <placeholder-1/> to use with Hibernate <placeholder-2/> API (defaults to <placeholder-3/>). <placeholder-4/>"
+msgstr ""
+
+#: configuration.xml:875(literal)
+msgid "jta.UserTransaction"
+msgstr ""
+
+#: configuration.xml:878(literal)
+msgid "JTATransactionFactory"
+msgstr ""
+
+#: configuration.xml:879(literal)
+msgid "UserTransaction"
+msgstr ""
+
+#: configuration.xml:877(entry)
+msgid "A JNDI name used by <placeholder-1/> to obtain the JTA <placeholder-2/> from the application server. <placeholder-3/>"
+msgstr ""
+
+#: configuration.xml:889(literal)
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr ""
+
+#: configuration.xml:892(literal)
+msgid "TransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:897(literal)
+msgid "classname.of.TransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:891(entry)
+msgid "The classname of a <placeholder-1/> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:903(literal)
+msgid "hibernate.transaction.flush_before_completion"
+msgstr ""
+
+#: configuration.xml:905(entry)
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:918(literal)
+msgid "hibernate.transaction.auto_close_session"
+msgstr ""
+
+#: configuration.xml:920(entry)
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:936(title)
+msgid "Miscellaneous Properties"
+msgstr ""
+
+#: configuration.xml:949(literal)
+msgid "hibernate.current_session_context_class"
+msgstr ""
+
+#: configuration.xml:953(literal)
+msgid "Session"
+msgstr ""
+
+#: configuration.xml:956(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis><literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr ""
+
+#: configuration.xml:951(entry)
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <placeholder-1/>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:965(literal)
+msgid "hibernate.query.factory_class"
+msgstr ""
+
+#: configuration.xml:969(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis><literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr ""
+
+#: configuration.xml:967(entry)
+msgid "Chooses the HQL parser implementation. <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:978(literal)
+msgid "hibernate.query.substitutions"
+msgstr ""
+
+#: configuration.xml:985(literal)
+msgid "hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC"
+msgstr ""
+
+#: configuration.xml:980(entry)
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example). <placeholder-1/>"
+msgstr ""
+
+#: configuration.xml:991(literal)
+msgid "hibernate.hbm2ddl.auto"
+msgstr ""
+
+#: configuration.xml:996(literal)
+msgid "create-drop"
+msgstr ""
+
+#: configuration.xml:999(para)
+msgid "<emphasis role=\"strong\">eg.</emphasis><literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr ""
+
+#: configuration.xml:993(entry)
+msgid "Automatically validate or export schema DDL to the database when the <placeholder-1/> is created. With <placeholder-2/>, the database schema will be dropped when the <placeholder-3/> is closed explicitly. <placeholder-4/>"
+msgstr ""
+
+#: configuration.xml:1008(literal)
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr ""
+
+#: configuration.xml:1014(literal)
+msgid "hibernate.cfg.xml"
+msgstr ""
+
+#: configuration.xml:1010(entry)
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <placeholder-1/>. <placeholder-2/>"
+msgstr ""
+
+#: configuration.xml:1026(title)
+msgid "SQL Dialects"
+msgstr ""
+
+#: configuration.xml:1028(para)
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr ""
+
+#: configuration.xml:1036(title)
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr ""
+
+#: configuration.xml:1044(entry)
+msgid "RDBMS"
+msgstr ""
+
+#: configuration.xml:1050(entry)
+msgid "DB2"
+msgstr ""
+
+#: configuration.xml:1050(literal)
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr ""
+
+#: configuration.xml:1053(entry)
+msgid "DB2 AS/400"
+msgstr ""
+
+#: configuration.xml:1053(literal)
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr ""
+
+#: configuration.xml:1056(entry)
+msgid "DB2 OS390"
+msgstr ""
+
+#: configuration.xml:1056(literal)
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr ""
+
+#: configuration.xml:1059(entry)
+msgid "PostgreSQL"
+msgstr ""
+
+#: configuration.xml:1059(literal)
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr ""
+
+#: configuration.xml:1062(entry)
+msgid "MySQL"
+msgstr ""
+
+#: configuration.xml:1062(literal)
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr ""
+
+#: configuration.xml:1065(entry)
+msgid "MySQL with InnoDB"
+msgstr ""
+
+#: configuration.xml:1065(literal)
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr ""
+
+#: configuration.xml:1068(entry)
+msgid "MySQL with MyISAM"
+msgstr ""
+
+#: configuration.xml:1068(literal)
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr ""
+
+#: configuration.xml:1071(entry)
+msgid "Oracle (any version)"
+msgstr ""
+
+#: configuration.xml:1071(literal)
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr ""
+
+#: configuration.xml:1074(entry)
+msgid "Oracle 9i/10g"
+msgstr ""
+
+#: configuration.xml:1074(literal)
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr ""
+
+#: configuration.xml:1077(entry)
+msgid "Sybase"
+msgstr ""
+
+#: configuration.xml:1077(literal)
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr ""
+
+#: configuration.xml:1080(entry)
+msgid "Sybase Anywhere"
+msgstr ""
+
+#: configuration.xml:1080(literal)
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr ""
+
+#: configuration.xml:1083(entry)
+msgid "Microsoft SQL Server"
+msgstr ""
+
+#: configuration.xml:1083(literal)
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr ""
+
+#: configuration.xml:1086(entry)
+msgid "SAP DB"
+msgstr ""
+
+#: configuration.xml:1086(literal)
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr ""
+
+#: configuration.xml:1089(entry)
+msgid "Informix"
+msgstr ""
+
+#: configuration.xml:1089(literal)
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr ""
+
+#: configuration.xml:1092(entry)
+msgid "HypersonicSQL"
+msgstr ""
+
+#: configuration.xml:1092(literal)
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr ""
+
+#: configuration.xml:1095(entry)
+msgid "Ingres"
+msgstr ""
+
+#: configuration.xml:1095(literal)
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr ""
+
+#: configuration.xml:1098(entry)
+msgid "Progress"
+msgstr ""
+
+#: configuration.xml:1098(literal)
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr ""
+
+#: configuration.xml:1101(entry)
+msgid "Mckoi SQL"
+msgstr ""
+
+#: configuration.xml:1101(literal)
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr ""
+
+#: configuration.xml:1104(entry)
+msgid "Interbase"
+msgstr ""
+
+#: configuration.xml:1104(literal)
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr ""
+
+#: configuration.xml:1107(entry)
+msgid "Pointbase"
+msgstr ""
+
+#: configuration.xml:1107(literal)
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr ""
+
+#: configuration.xml:1110(entry)
+msgid "FrontBase"
+msgstr ""
+
+#: configuration.xml:1110(literal)
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr ""
+
+#: configuration.xml:1113(entry)
+msgid "Firebird"
+msgstr ""
+
+#: configuration.xml:1113(literal)
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr ""
+
+#: configuration.xml:1122(title)
+msgid "Outer Join Fetching"
+msgstr ""
+
+#: configuration.xml:1124(para)
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr ""
+
+#: configuration.xml:1133(para)
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr ""
+
+#: configuration.xml:1141(para)
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: configuration.xml:1148(title)
+msgid "Binary Streams"
+msgstr ""
+
+#: configuration.xml:1150(para)
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr ""
+
+#: configuration.xml:1161(title)
+msgid "Second-level and query cache"
+msgstr ""
+
+#: configuration.xml:1163(para)
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr ""
+
+#: configuration.xml:1173(title)
+msgid "Query Language Substitution"
+msgstr ""
+
+#: configuration.xml:1175(para)
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr ""
+
+#: configuration.xml:1180(programlisting)
+#, no-wrap
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr ""
+
+#: configuration.xml:1182(para)
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr ""
+
+#: configuration.xml:1187(programlisting)
+#, no-wrap
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr ""
+
+#: configuration.xml:1189(para)
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr ""
+
+#: configuration.xml:1196(title)
+msgid "Hibernate statistics"
+msgstr ""
+
+#: configuration.xml:1198(para)
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr ""
+
+#: configuration.xml:1210(title)
+msgid "Logging"
+msgstr ""
+
+#: configuration.xml:1212(para)
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr ""
+
+#: configuration.xml:1216(para)
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr ""
+
+#: configuration.xml:1226(para)
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr ""
+
+#: configuration.xml:1235(title)
+msgid "Hibernate Log Categories"
+msgstr ""
+
+#: configuration.xml:1241(entry)
+msgid "Category"
+msgstr ""
+
+#: configuration.xml:1242(entry)
+msgid "Function"
+msgstr ""
+
+#: configuration.xml:1248(entry)
+msgid "Log all SQL DML statements as they are executed"
+msgstr ""
+
+#: configuration.xml:1251(literal)
+msgid "org.hibernate.type"
+msgstr ""
+
+#: configuration.xml:1252(entry)
+msgid "Log all JDBC parameters"
+msgstr ""
+
+#: configuration.xml:1255(literal)
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr ""
+
+#: configuration.xml:1256(entry)
+msgid "Log all SQL DDL statements as they are executed"
+msgstr ""
+
+#: configuration.xml:1259(literal)
+msgid "org.hibernate.pretty"
+msgstr ""
+
+#: configuration.xml:1260(entry)
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr ""
+
+#: configuration.xml:1266(literal)
+msgid "org.hibernate.cache"
+msgstr ""
+
+#: configuration.xml:1267(entry)
+msgid "Log all second-level cache activity"
+msgstr ""
+
+#: configuration.xml:1270(literal)
+msgid "org.hibernate.transaction"
+msgstr ""
+
+#: configuration.xml:1271(entry)
+msgid "Log transaction related activity"
+msgstr ""
+
+#: configuration.xml:1274(literal)
+msgid "org.hibernate.jdbc"
+msgstr ""
+
+#: configuration.xml:1275(entry)
+msgid "Log all JDBC resource acquisition"
+msgstr ""
+
+#: configuration.xml:1278(literal)
+msgid "org.hibernate.hql.ast.AST"
+msgstr ""
+
+#: configuration.xml:1279(entry)
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr ""
+
+#: configuration.xml:1284(literal)
+msgid "org.hibernate.secure"
+msgstr ""
+
+#: configuration.xml:1285(entry)
+msgid "Log all JAAS authorization requests"
+msgstr ""
+
+#: configuration.xml:1288(literal)
+msgid "org.hibernate"
+msgstr ""
+
+#: configuration.xml:1289(entry)
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr ""
+
+#: configuration.xml:1298(para)
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr ""
+
+#: configuration.xml:1308(title)
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr ""
+
+#: configuration.xml:1310(para)
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr ""
+
+#: configuration.xml:1315(para)
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr ""
+
+#: configuration.xml:1324(para)
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr ""
+
+#: configuration.xml:1335(para)
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr ""
+
+#: configuration.xml:1343(title)
+msgid "XML configuration file"
+msgstr ""
+
+#: configuration.xml:1345(para)
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr ""
+
+#: configuration.xml:1352(para)
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr ""
+
+#: configuration.xml:1390(para)
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr ""
+
+#: configuration.xml:1399(para)
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr ""
+
+#: configuration.xml:1405(para)
+msgid "You can pick a different XML configuration file using"
+msgstr ""
+
+#: configuration.xml:1416(title)
+msgid "J2EE Application Server integration"
+msgstr ""
+
+#: configuration.xml:1418(para)
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr ""
+
+#: configuration.xml:1424(para)
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr ""
+
+#: configuration.xml:1439(para)
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr ""
+
+#: configuration.xml:1448(para)
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr ""
+
+#: configuration.xml:1461(para)
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr ""
+
+#: configuration.xml:1472(para)
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr ""
+
+#: configuration.xml:1479(title)
+msgid "Transaction strategy configuration"
+msgstr ""
+
+#: configuration.xml:1481(para)
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr ""
+
+#: configuration.xml:1489(para)
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr ""
+
+#: configuration.xml:1496(para)
+msgid "There are three standard (built-in) choices:"
+msgstr ""
+
+#: configuration.xml:1502(literal)
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr ""
+
+#: configuration.xml:1504(para)
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr ""
+
+#: configuration.xml:1508(literal)
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr ""
+
+#: configuration.xml:1510(para)
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr ""
+
+#: configuration.xml:1518(literal)
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr ""
+
+#: configuration.xml:1520(para)
+msgid "delegates to container-managed JTA transactions"
+msgstr ""
+
+#: configuration.xml:1525(para)
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr ""
+
+#: configuration.xml:1530(para)
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr ""
+
+#: configuration.xml:1538(title)
+msgid "JTA TransactionManagers"
+msgstr ""
+
+#: configuration.xml:1544(entry)
+msgid "Transaction Factory"
+msgstr ""
+
+#: configuration.xml:1545(entry)
+msgid "Application Server"
+msgstr ""
+
+#: configuration.xml:1550(literal)
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1551(entry)
+msgid "JBoss"
+msgstr ""
+
+#: configuration.xml:1554(literal)
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1555(entry)
+msgid "Weblogic"
+msgstr ""
+
+#: configuration.xml:1558(literal)
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1559(entry)
+msgid "WebSphere"
+msgstr ""
+
+#: configuration.xml:1562(literal)
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr ""
+
+#: configuration.xml:1563(entry)
+msgid "WebSphere 6"
+msgstr ""
+
+#: configuration.xml:1566(literal)
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1567(entry)
+msgid "Orion"
+msgstr ""
+
+#: configuration.xml:1570(literal)
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1571(entry)
+msgid "Resin"
+msgstr ""
+
+#: configuration.xml:1574(literal)
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1575(entry)
+msgid "JOTM"
+msgstr ""
+
+#: configuration.xml:1578(literal)
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1579(entry)
+msgid "JOnAS"
+msgstr ""
+
+#: configuration.xml:1582(literal)
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1583(entry)
+msgid "JRun4"
+msgstr ""
+
+#: configuration.xml:1586(literal)
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr ""
+
+#: configuration.xml:1587(entry)
+msgid "Borland ES"
+msgstr ""
+
+#: configuration.xml:1596(title)
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr ""
+
+#: configuration.xml:1598(para)
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr ""
+
+#: configuration.xml:1605(para)
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr ""
+
+#: configuration.xml:1613(para)
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr ""
+
+#: configuration.xml:1620(para)
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr ""
+
+#: configuration.xml:1627(para)
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr ""
+
+#: configuration.xml:1632(para)
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr ""
+
+#: configuration.xml:1644(title)
+msgid "Current Session context management with JTA"
+msgstr ""
+
+#: configuration.xml:1646(para)
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\">current sessions</xref>. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of su!
ch management concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr ""
+
+#: configuration.xml:1669(title)
+msgid "JMX deployment"
+msgstr ""
+
+#: configuration.xml:1671(para)
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr ""
+
+#: configuration.xml:1679(para)
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr ""
+
+#: configuration.xml:1729(para)
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: configuration.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/events.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/events.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/events.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,108 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:31-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: events.xml:5(title)
+msgid "Interceptors and events"
+msgstr ""
+
+#: events.xml:7(para)
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr ""
+
+#: events.xml:14(title)
+msgid "Interceptors"
+msgstr ""
+
+#: events.xml:16(para)
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr ""
+
+#: events.xml:27(para)
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr ""
+
+#: events.xml:115(para)
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr ""
+
+#: events.xml:120(para)
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr ""
+
+#: events.xml:128(para)
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr ""
+
+#: events.xml:142(title)
+msgid "Event system"
+msgstr ""
+
+#: events.xml:144(para)
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr ""
+
+#: events.xml:150(para)
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr ""
+
+#: events.xml:165(para)
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr ""
+
+#: events.xml:170(para)
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr ""
+
+#: events.xml:190(para)
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr ""
+
+#: events.xml:205(para)
+msgid "Instead, you may register it programmatically:"
+msgstr ""
+
+#: events.xml:213(para)
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr ""
+
+#: events.xml:221(para)
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr ""
+
+#: events.xml:231(title)
+msgid "Hibernate declarative security"
+msgstr ""
+
+#: events.xml:232(para)
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr ""
+
+#: events.xml:238(para)
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr ""
+
+#: events.xml:248(para)
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr ""
+
+#: events.xml:254(para)
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+
+#: events.xml:261(para)
+msgid "The role names are the roles understood by your JACC provider."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: events.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/example_mappings.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/example_mappings.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/example_mappings.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,122 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:31-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: example_mappings.xml:39(None) example_mappings.xml:42(None)
+msgid "@@image: '../images/EmployerEmployee.png'; md5=51e3da273e772b7defc753746eb5223f"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: example_mappings.xml:153(None) example_mappings.xml:156(None)
+msgid "@@image: '../images/AuthorWork.png'; md5=fdbc5f105890c04d206674e7df6af6cf"
+msgstr ""
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: example_mappings.xml:277(None) example_mappings.xml:280(None)
+msgid "@@image: '../images/CustomerOrderProduct.png'; md5=39dcb639a197684dc020904a3f9a4b3d"
+msgstr ""
+
+#: example_mappings.xml:20(title)
+msgid "Example: Various Mappings"
+msgstr ""
+
+#: example_mappings.xml:22(para)
+msgid "This chapters shows off some more complex association mappings."
+msgstr ""
+
+#: example_mappings.xml:27(title)
+msgid "Employer/Employee"
+msgstr ""
+
+#: example_mappings.xml:29(para)
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr ""
+
+#: example_mappings.xml:46(para)
+msgid "Heres a possible mapping document:"
+msgstr ""
+
+#: example_mappings.xml:99(para)
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: example_mappings.xml:140(title)
+msgid "Author/Work"
+msgstr ""
+
+#: example_mappings.xml:142(para)
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr ""
+
+#: example_mappings.xml:160(para)
+msgid "The following mapping document correctly represents these relationships:"
+msgstr ""
+
+#: example_mappings.xml:216(para)
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: example_mappings.xml:262(title)
+msgid "Customer/Order/Product"
+msgstr ""
+
+#: example_mappings.xml:264(para)
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr ""
+
+#: example_mappings.xml:284(para)
+msgid "The mapping document:"
+msgstr ""
+
+#: example_mappings.xml:326(para)
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr ""
+
+#: example_mappings.xml:370(title)
+msgid "Miscellaneous example mappings"
+msgstr ""
+
+#: example_mappings.xml:372(para)
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr ""
+
+#: example_mappings.xml:378(para)
+msgid "TODO: put words around this stuff"
+msgstr ""
+
+#: example_mappings.xml:381(title)
+msgid "\"Typed\" one-to-one association"
+msgstr ""
+
+#: example_mappings.xml:411(title)
+msgid "Composite key example"
+msgstr ""
+
+#: example_mappings.xml:528(title)
+msgid "Many-to-many with shared composite key attribute"
+msgstr ""
+
+#: example_mappings.xml:567(title)
+msgid "Content based discrimination"
+msgstr ""
+
+#: example_mappings.xml:621(title)
+msgid "Associations on alternate keys"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: example_mappings.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/example_parentchild.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/example_parentchild.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/example_parentchild.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:31-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: example_parentchild.xml:5(title)
+msgid "Example: Parent/Child"
+msgstr ""
+
+#: example_parentchild.xml:7(para)
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr ""
+
+#: example_parentchild.xml:21(title)
+msgid "A note about collections"
+msgstr ""
+
+#: example_parentchild.xml:23(para)
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr ""
+
+#: example_parentchild.xml:30(para)
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr ""
+
+#: example_parentchild.xml:36(para)
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr ""
+
+#: example_parentchild.xml:44(para)
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr ""
+
+#: example_parentchild.xml:54(para)
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr ""
+
+#: example_parentchild.xml:64(title)
+msgid "Bidirectional one-to-many"
+msgstr ""
+
+#: example_parentchild.xml:66(para)
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr ""
+
+#: example_parentchild.xml:76(para)
+msgid "If we were to execute the following code"
+msgstr ""
+
+#: example_parentchild.xml:86(para)
+msgid "Hibernate would issue two SQL statements:"
+msgstr ""
+
+#: example_parentchild.xml:92(para)
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr ""
+
+#: example_parentchild.xml:95(para)
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr ""
+
+#: example_parentchild.xml:102(para)
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr ""
+
+#: example_parentchild.xml:113(para)
+msgid "However, this is not the recommended solution."
+msgstr ""
+
+#: example_parentchild.xml:116(para)
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr ""
+
+#: example_parentchild.xml:125(para)
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr ""
+
+#: example_parentchild.xml:129(para)
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr ""
+
+#: example_parentchild.xml:139(para)
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr ""
+
+#: example_parentchild.xml:150(para)
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr ""
+
+#: example_parentchild.xml:154(para)
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr ""
+
+#: example_parentchild.xml:164(para)
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr ""
+
+#: example_parentchild.xml:177(title)
+msgid "Cascading life cycle"
+msgstr ""
+
+#: example_parentchild.xml:179(para)
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr ""
+
+#: example_parentchild.xml:189(para)
+msgid "This simplifies the code above to"
+msgstr ""
+
+#: example_parentchild.xml:198(para)
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr ""
+
+#: example_parentchild.xml:207(para)
+msgid "However, this code"
+msgstr ""
+
+#: example_parentchild.xml:217(para)
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr ""
+
+#: example_parentchild.xml:229(para)
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr ""
+
+#: example_parentchild.xml:240(para)
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr ""
+
+#: example_parentchild.xml:250(title)
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr ""
+
+#: example_parentchild.xml:252(para)
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr ""
+
+#: example_parentchild.xml:264(para)
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr ""
+
+#: example_parentchild.xml:276(para)
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr ""
+
+#: example_parentchild.xml:348(title)
+msgid "Conclusion"
+msgstr ""
+
+#: example_parentchild.xml:350(para)
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr ""
+
+#: example_parentchild.xml:355(para)
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: example_parentchild.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/example_weblog.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/example_weblog.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/example_weblog.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,44 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:32-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: example_weblog.xml:5(title)
+msgid "Example: Weblog Application"
+msgstr ""
+
+#: example_weblog.xml:8(title)
+msgid "Persistent Classes"
+msgstr ""
+
+#: example_weblog.xml:10(para)
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr ""
+
+#: example_weblog.xml:92(title)
+msgid "Hibernate Mappings"
+msgstr ""
+
+#: example_weblog.xml:94(para)
+msgid "The XML mappings should now be quite straightforward."
+msgstr ""
+
+#: example_weblog.xml:185(title)
+msgid "Hibernate Code"
+msgstr ""
+
+#: example_weblog.xml:187(para)
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: example_weblog.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/filters.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/filters.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/filters.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,80 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:32-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: filters.xml:5(title)
+msgid "Filtering data"
+msgstr ""
+
+#: filters.xml:7(para)
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr ""
+
+#: filters.xml:14(title)
+msgid "Hibernate filters"
+msgstr ""
+
+#: filters.xml:16(para)
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr ""
+
+#: filters.xml:26(para)
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr ""
+
+#: filters.xml:36(para)
+msgid "Then, this filter can be attached to a class:"
+msgstr ""
+
+#: filters.xml:45(para)
+msgid "or, to a collection:"
+msgstr ""
+
+#: filters.xml:53(para)
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr ""
+
+#: filters.xml:57(para)
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr ""
+
+#: filters.xml:68(para)
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr ""
+
+#: filters.xml:72(para)
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr ""
+
+#: filters.xml:104(para)
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr ""
+
+#: filters.xml:116(para)
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr ""
+
+#: filters.xml:122(para)
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr ""
+
+#: filters.xml:129(para)
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: filters.xml:139(para)
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: filters.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/inheritance_mapping.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/inheritance_mapping.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/inheritance_mapping.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,280 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:32-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: inheritance_mapping.xml:5(title)
+msgid "Inheritance Mapping"
+msgstr ""
+
+#: inheritance_mapping.xml:8(title)
+msgid "The Three Strategies"
+msgstr ""
+
+#: inheritance_mapping.xml:10(para)
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr ""
+
+#: inheritance_mapping.xml:16(para)
+msgid "table per class hierarchy"
+msgstr ""
+
+#: inheritance_mapping.xml:21(para) inheritance_mapping.xml:456(entry)
+msgid "table per subclass"
+msgstr ""
+
+#: inheritance_mapping.xml:26(para)
+msgid "table per concrete class"
+msgstr ""
+
+#: inheritance_mapping.xml:32(para)
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr ""
+
+#: inheritance_mapping.xml:39(para)
+msgid "implicit polymorphism"
+msgstr ""
+
+#: inheritance_mapping.xml:45(para)
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr ""
+
+#: inheritance_mapping.xml:59(para)
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr ""
+
+#: inheritance_mapping.xml:79(title)
+msgid "Table per class hierarchy"
+msgstr ""
+
+#: inheritance_mapping.xml:81(para)
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr ""
+
+#: inheritance_mapping.xml:107(para)
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr ""
+
+#: inheritance_mapping.xml:116(title)
+msgid "Table per subclass"
+msgstr ""
+
+#: inheritance_mapping.xml:118(para)
+msgid "A table per subclass mapping would look like:"
+msgstr ""
+
+#: inheritance_mapping.xml:143(para)
+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 ""
+
+#: inheritance_mapping.xml:152(title)
+msgid "Table per subclass, using a discriminator"
+msgstr ""
+
+#: inheritance_mapping.xml:154(para)
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr ""
+
+#: inheritance_mapping.xml:194(para)
+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 ""
+
+#: inheritance_mapping.xml:203(title)
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr ""
+
+#: inheritance_mapping.xml:205(para)
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr ""
+
+#: inheritance_mapping.xml:231(para)
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr ""
+
+#: inheritance_mapping.xml:242(title)
+msgid "Table per concrete class"
+msgstr ""
+
+#: inheritance_mapping.xml:244(para)
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr ""
+
+#: inheritance_mapping.xml:267(para)
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr ""
+
+#: inheritance_mapping.xml:272(para)
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr ""
+
+#: inheritance_mapping.xml:281(para)
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr ""
+
+#: inheritance_mapping.xml:291(title)
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr ""
+
+#: inheritance_mapping.xml:293(para)
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr ""
+
+#: inheritance_mapping.xml:321(para)
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr ""
+
+#: inheritance_mapping.xml:331(para)
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr ""
+
+#: inheritance_mapping.xml:336(para)
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr ""
+
+#: inheritance_mapping.xml:352(title)
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr ""
+
+#: inheritance_mapping.xml:354(para)
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr ""
+
+#: inheritance_mapping.xml:390(para)
+msgid "Once again, we don't mention <literal>Payment</literal> 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 ""
+
+#: inheritance_mapping.xml:405(title)
+msgid "Limitations"
+msgstr ""
+
+#: inheritance_mapping.xml:407(para)
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr ""
+
+#: inheritance_mapping.xml:414(para)
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr ""
+
+#: inheritance_mapping.xml:420(title)
+msgid "Features of inheritance mappings"
+msgstr ""
+
+#: inheritance_mapping.xml:432(entry)
+msgid "Inheritance strategy"
+msgstr ""
+
+#: inheritance_mapping.xml:433(entry)
+msgid "Polymorphic many-to-one"
+msgstr ""
+
+#: inheritance_mapping.xml:434(entry)
+msgid "Polymorphic one-to-one"
+msgstr ""
+
+#: inheritance_mapping.xml:435(entry)
+msgid "Polymorphic one-to-many"
+msgstr ""
+
+#: inheritance_mapping.xml:436(entry)
+msgid "Polymorphic many-to-many"
+msgstr ""
+
+#: inheritance_mapping.xml:437(literal)
+msgid "load()/get()"
+msgstr ""
+
+#: inheritance_mapping.xml:437(entry)
+msgid "Polymorphic <placeholder-1/>"
+msgstr ""
+
+#: inheritance_mapping.xml:438(entry)
+msgid "Polymorphic queries"
+msgstr ""
+
+#: inheritance_mapping.xml:439(entry)
+msgid "Polymorphic joins"
+msgstr ""
+
+#: inheritance_mapping.xml:440(entry)
+msgid "Outer join fetching"
+msgstr ""
+
+#: inheritance_mapping.xml:445(entry)
+msgid "table per class-hierarchy"
+msgstr ""
+
+#: inheritance_mapping.xml:446(literal) inheritance_mapping.xml:457(literal) inheritance_mapping.xml:468(literal)
+msgid "<many-to-one>"
+msgstr ""
+
+#: inheritance_mapping.xml:447(literal) inheritance_mapping.xml:458(literal) inheritance_mapping.xml:469(literal)
+msgid "<one-to-one>"
+msgstr ""
+
+#: inheritance_mapping.xml:448(literal) inheritance_mapping.xml:459(literal) inheritance_mapping.xml:470(literal)
+msgid "<one-to-many>"
+msgstr ""
+
+#: inheritance_mapping.xml:449(literal) inheritance_mapping.xml:460(literal) inheritance_mapping.xml:471(literal)
+msgid "<many-to-many>"
+msgstr ""
+
+#: inheritance_mapping.xml:450(literal) inheritance_mapping.xml:461(literal) inheritance_mapping.xml:472(literal)
+msgid "s.get(Payment.class, id)"
+msgstr ""
+
+#: inheritance_mapping.xml:451(literal) inheritance_mapping.xml:462(literal) inheritance_mapping.xml:473(literal) inheritance_mapping.xml:484(literal)
+msgid "from Payment p"
+msgstr ""
+
+#: inheritance_mapping.xml:452(literal) inheritance_mapping.xml:463(literal) inheritance_mapping.xml:474(literal)
+msgid "from Order o join o.payment p"
+msgstr ""
+
+#: inheritance_mapping.xml:453(emphasis) inheritance_mapping.xml:464(emphasis) inheritance_mapping.xml:475(emphasis)
+msgid "supported"
+msgstr ""
+
+#: inheritance_mapping.xml:467(entry)
+msgid "table per concrete-class (union-subclass)"
+msgstr ""
+
+#: inheritance_mapping.xml:470(literal)
+msgid "inverse=\"true\""
+msgstr ""
+
+#: inheritance_mapping.xml:470(entry)
+msgid "<placeholder-1/> (for <placeholder-2/> only)"
+msgstr ""
+
+#: inheritance_mapping.xml:478(entry)
+msgid "table per concrete class (implicit polymorphism)"
+msgstr ""
+
+#: inheritance_mapping.xml:479(literal)
+msgid "<any>"
+msgstr ""
+
+#: inheritance_mapping.xml:480(emphasis) inheritance_mapping.xml:481(emphasis) inheritance_mapping.xml:485(emphasis) inheritance_mapping.xml:486(emphasis)
+msgid "not supported"
+msgstr ""
+
+#: inheritance_mapping.xml:482(literal)
+msgid "<many-to-any>"
+msgstr ""
+
+#: inheritance_mapping.xml:483(literal)
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: inheritance_mapping.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/performance.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/performance.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/performance.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,808 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:32-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: performance.xml:5(title)
+msgid "Improving performance"
+msgstr ""
+
+#: performance.xml:8(title)
+msgid "Fetching strategies"
+msgstr ""
+
+#: performance.xml:10(para)
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr ""
+
+#: performance.xml:17(para)
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr ""
+
+#: performance.xml:23(para)
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr ""
+
+#: performance.xml:30(para)
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: performance.xml:39(para)
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: performance.xml:48(para)
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr ""
+
+#: performance.xml:57(para)
+msgid "Hibernate also distinguishes between:"
+msgstr ""
+
+#: performance.xml:63(para)
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr ""
+
+#: performance.xml:69(para)
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr ""
+
+#: performance.xml:76(para)
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr ""
+
+#: performance.xml:84(para)
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr ""
+
+#: performance.xml:91(para)
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: performance.xml:101(para)
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: performance.xml:110(para)
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr ""
+
+#: performance.xml:119(title)
+msgid "Working with lazy associations"
+msgstr ""
+
+#: performance.xml:121(para)
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr ""
+
+#: performance.xml:127(para)
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr ""
+
+#: performance.xml:134(para)
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr ""
+
+#: performance.xml:152(para)
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr ""
+
+#: performance.xml:160(para)
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr ""
+
+#: performance.xml:169(para)
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr ""
+
+#: performance.xml:180(title)
+msgid "Tuning fetch strategies"
+msgstr ""
+
+#: performance.xml:182(para)
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr ""
+
+#: performance.xml:195(para)
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr ""
+
+#: performance.xml:201(para)
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr ""
+
+#: performance.xml:206(para)
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr ""
+
+#: performance.xml:211(para)
+msgid "<literal>Criteria</literal> queries"
+msgstr ""
+
+#: performance.xml:216(para)
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr ""
+
+#: performance.xml:222(para)
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr ""
+
+#: performance.xml:228(para)
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr ""
+
+#: performance.xml:237(para)
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr ""
+
+#: performance.xml:248(para)
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr ""
+
+#: performance.xml:252(para)
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr ""
+
+#: performance.xml:260(title)
+msgid "Single-ended association proxies"
+msgstr ""
+
+#: performance.xml:262(para)
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr ""
+
+#: performance.xml:270(para)
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr ""
+
+#: performance.xml:276(para)
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr ""
+
+#: performance.xml:283(para)
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr ""
+
+#: performance.xml:295(para)
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr ""
+
+#: performance.xml:307(para)
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr ""
+
+#: performance.xml:316(para)
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr ""
+
+#: performance.xml:324(para)
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr ""
+
+#: performance.xml:329(para)
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr ""
+
+#: performance.xml:335(para)
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr ""
+
+#: performance.xml:348(para)
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr ""
+
+#: performance.xml:360(para)
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr ""
+
+#: performance.xml:365(para)
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr ""
+
+#: performance.xml:371(para)
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr ""
+
+#: performance.xml:377(para)
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr ""
+
+#: performance.xml:383(para)
+msgid "The identifier getter method"
+msgstr ""
+
+#: performance.xml:389(para)
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr ""
+
+#: performance.xml:394(para)
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr ""
+
+#: performance.xml:404(title)
+msgid "Initializing collections and proxies"
+msgstr ""
+
+#: performance.xml:406(para)
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr ""
+
+#: performance.xml:412(para)
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr ""
+
+#: performance.xml:419(para)
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr ""
+
+#: performance.xml:428(para)
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr ""
+
+#: performance.xml:439(para)
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr ""
+
+#: performance.xml:452(para)
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr ""
+
+#: performance.xml:467(para)
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr ""
+
+#: performance.xml:477(para)
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr ""
+
+#: performance.xml:482(para)
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr ""
+
+#: performance.xml:488(para)
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr ""
+
+#: performance.xml:498(title)
+msgid "Using batch fetching"
+msgstr ""
+
+#: performance.xml:500(para)
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr ""
+
+#: performance.xml:506(para)
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr ""
+
+#: performance.xml:518(para)
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr ""
+
+#: performance.xml:522(para)
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr ""
+
+#: performance.xml:537(para)
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr ""
+
+#: performance.xml:543(para)
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr ""
+
+#: performance.xml:552(title)
+msgid "Using subselect fetching"
+msgstr ""
+
+#: performance.xml:554(para)
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr ""
+
+#: performance.xml:565(title)
+msgid "Using lazy property fetching"
+msgstr ""
+
+#: performance.xml:567(para)
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr ""
+
+#: performance.xml:576(para)
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr ""
+
+#: performance.xml:590(para)
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr ""
+
+#: performance.xml:596(para)
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr ""
+
+#: performance.xml:614(para)
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr ""
+
+#: performance.xml:621(para)
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr ""
+
+#: performance.xml:631(title)
+msgid "The Second Level Cache"
+msgstr ""
+
+#: performance.xml:633(para)
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr ""
+
+#: performance.xml:641(para)
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr ""
+
+#: performance.xml:652(title)
+msgid "Cache Providers"
+msgstr ""
+
+#: performance.xml:661(entry) performance.xml:848(entry)
+msgid "Cache"
+msgstr ""
+
+#: performance.xml:662(entry)
+msgid "Provider class"
+msgstr ""
+
+#: performance.xml:663(entry)
+msgid "Type"
+msgstr ""
+
+#: performance.xml:664(entry)
+msgid "Cluster Safe"
+msgstr ""
+
+#: performance.xml:665(entry)
+msgid "Query Cache Supported"
+msgstr ""
+
+#: performance.xml:670(entry) performance.xml:857(entry)
+msgid "Hashtable (not intended for production use)"
+msgstr ""
+
+#: performance.xml:671(literal)
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr ""
+
+#: performance.xml:672(entry)
+msgid "memory"
+msgstr ""
+
+#: performance.xml:674(entry) performance.xml:681(entry) performance.xml:688(entry) performance.xml:858(entry) performance.xml:859(entry) performance.xml:860(entry) performance.xml:865(entry) performance.xml:866(entry) performance.xml:867(entry) performance.xml:872(entry) performance.xml:873(entry) performance.xml:874(entry) performance.xml:879(entry) performance.xml:880(entry) performance.xml:886(entry) performance.xml:889(entry)
+msgid "yes"
+msgstr ""
+
+#: performance.xml:677(entry) performance.xml:864(entry)
+msgid "EHCache"
+msgstr ""
+
+#: performance.xml:678(literal)
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr ""
+
+#: performance.xml:679(entry) performance.xml:686(entry)
+msgid "memory, disk"
+msgstr ""
+
+#: performance.xml:684(entry) performance.xml:871(entry)
+msgid "OSCache"
+msgstr ""
+
+#: performance.xml:685(literal)
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr ""
+
+#: performance.xml:691(entry) performance.xml:878(entry)
+msgid "SwarmCache"
+msgstr ""
+
+#: performance.xml:692(literal)
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr ""
+
+#: performance.xml:693(entry)
+msgid "clustered (ip multicast)"
+msgstr ""
+
+#: performance.xml:694(entry)
+msgid "yes (clustered invalidation)"
+msgstr ""
+
+#: performance.xml:698(entry) performance.xml:885(entry)
+msgid "JBoss TreeCache"
+msgstr ""
+
+#: performance.xml:699(literal)
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr ""
+
+#: performance.xml:700(entry)
+msgid "clustered (ip multicast), transactional"
+msgstr ""
+
+#: performance.xml:701(entry)
+msgid "yes (replication)"
+msgstr ""
+
+#: performance.xml:702(entry)
+msgid "yes (clock sync req.)"
+msgstr ""
+
+#: performance.xml:709(title)
+msgid "Cache mappings"
+msgstr ""
+
+#: performance.xml:711(para)
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr ""
+
+#: performance.xml:729(para)
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+
+#: performance.xml:738(para)
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr ""
+
+#: performance.xml:745(para)
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr ""
+
+#: performance.xml:755(para)
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+
+#: performance.xml:760(para)
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr ""
+
+#: performance.xml:767(title)
+msgid "Strategy: read only"
+msgstr ""
+
+#: performance.xml:769(para)
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr ""
+
+#: performance.xml:784(title)
+msgid "Strategy: read/write"
+msgstr ""
+
+#: performance.xml:786(para)
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr ""
+
+#: performance.xml:809(title)
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+
+#: performance.xml:811(para)
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr ""
+
+#: performance.xml:823(title)
+msgid "Strategy: transactional"
+msgstr ""
+
+#: performance.xml:825(para)
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: performance.xml:833(para)
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr ""
+
+#: performance.xml:839(title)
+msgid "Cache Concurrency Strategy Support"
+msgstr ""
+
+#: performance.xml:849(entry)
+msgid "read-only"
+msgstr ""
+
+#: performance.xml:850(entry)
+msgid "nonstrict-read-write"
+msgstr ""
+
+#: performance.xml:851(entry)
+msgid "read-write"
+msgstr ""
+
+#: performance.xml:852(entry)
+msgid "transactional"
+msgstr ""
+
+#: performance.xml:898(title)
+msgid "Managing the caches"
+msgstr ""
+
+#: performance.xml:900(para)
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr ""
+
+#: performance.xml:907(para)
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr ""
+
+#: performance.xml:922(para)
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+
+#: performance.xml:927(para)
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr ""
+
+#: performance.xml:931(para)
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr ""
+
+#: performance.xml:942(para)
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+
+#: performance.xml:949(para)
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr ""
+
+#: performance.xml:954(para)
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr ""
+
+#: performance.xml:960(para)
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr ""
+
+#: performance.xml:966(para)
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr ""
+
+#: performance.xml:974(para)
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr ""
+
+#: performance.xml:983(para)
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+
+#: performance.xml:994(title)
+msgid "The Query Cache"
+msgstr ""
+
+#: performance.xml:996(para)
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr ""
+
+#: performance.xml:1003(para)
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr ""
+
+#: performance.xml:1013(para)
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr ""
+
+#: performance.xml:1020(para)
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr ""
+
+#: performance.xml:1033(para)
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+
+#: performance.xml:1045(title)
+msgid "Understanding Collection performance"
+msgstr ""
+
+#: performance.xml:1047(para)
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr ""
+
+#: performance.xml:1054(title)
+msgid "Taxonomy"
+msgstr ""
+
+#: performance.xml:1056(para)
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr ""
+
+#: performance.xml:1060(para)
+msgid "collections of values"
+msgstr ""
+
+#: performance.xml:1063(para)
+msgid "one to many associations"
+msgstr ""
+
+#: performance.xml:1066(para)
+msgid "many to many associations"
+msgstr ""
+
+#: performance.xml:1070(para)
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr ""
+
+#: performance.xml:1081(para)
+msgid "indexed collections"
+msgstr ""
+
+#: performance.xml:1084(para)
+msgid "sets"
+msgstr ""
+
+#: performance.xml:1087(para)
+msgid "bags"
+msgstr ""
+
+#: performance.xml:1091(para)
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr ""
+
+#: performance.xml:1099(para)
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr ""
+
+#: performance.xml:1110(para)
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr ""
+
+#: performance.xml:1115(para)
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr ""
+
+#: performance.xml:1123(para)
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr ""
+
+#: performance.xml:1133(title)
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr ""
+
+#: performance.xml:1135(para)
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr ""
+
+#: performance.xml:1141(para)
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr ""
+
+#: performance.xml:1150(para)
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr ""
+
+#: performance.xml:1158(para)
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr ""
+
+#: performance.xml:1168(title)
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr ""
+
+#: performance.xml:1170(para)
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr ""
+
+#: performance.xml:1189(title)
+msgid "One shot delete"
+msgstr ""
+
+#: performance.xml:1191(para)
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr ""
+
+#: performance.xml:1198(para)
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr ""
+
+#: performance.xml:1204(para)
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr ""
+
+#: performance.xml:1211(para)
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr ""
+
+#: performance.xml:1214(para)
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr ""
+
+#: performance.xml:1219(para)
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr ""
+
+#: performance.xml:1225(para)
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr ""
+
+#: performance.xml:1231(para)
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: performance.xml:1240(title)
+msgid "Monitoring performance"
+msgstr ""
+
+#: performance.xml:1242(para)
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr ""
+
+#: performance.xml:1249(title)
+msgid "Monitoring a SessionFactory"
+msgstr ""
+
+#: performance.xml:1251(para)
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr ""
+
+#: performance.xml:1257(para)
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr ""
+
+#: performance.xml:1284(para)
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+
+#: performance.xml:1289(para)
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr ""
+
+#: performance.xml:1294(para)
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr ""
+
+#: performance.xml:1301(para)
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr ""
+
+#: performance.xml:1308(para)
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr ""
+
+#: performance.xml:1317(title)
+msgid "Metrics"
+msgstr ""
+
+#: performance.xml:1319(para)
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr ""
+
+#: performance.xml:1326(para)
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr ""
+
+#: performance.xml:1332(para)
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr ""
+
+#: performance.xml:1338(para)
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr ""
+
+#: performance.xml:1345(para)
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr ""
+
+#: performance.xml:1352(para)
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr ""
+
+#: performance.xml:1379(para)
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: performance.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/persistent_classes.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/persistent_classes.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/persistent_classes.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,208 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:33-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: persistent_classes.xml:5(title)
+msgid "Persistent Classes"
+msgstr ""
+
+#: persistent_classes.xml:7(para)
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr ""
+
+#: persistent_classes.xml:14(para)
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr ""
+
+#: persistent_classes.xml:23(title)
+msgid "A simple POJO example"
+msgstr ""
+
+#: persistent_classes.xml:25(para)
+msgid "Most Java applications require a persistent class representing felines."
+msgstr ""
+
+#: persistent_classes.xml:108(para)
+msgid "There are four main rules to follow here:"
+msgstr ""
+
+#: persistent_classes.xml:114(title)
+msgid "Implement a no-argument constructor"
+msgstr ""
+
+#: persistent_classes.xml:116(para)
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr ""
+
+#: persistent_classes.xml:126(title)
+msgid "Provide an identifier property (optional)"
+msgstr ""
+
+#: persistent_classes.xml:128(para)
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr ""
+
+#: persistent_classes.xml:137(para)
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr ""
+
+#: persistent_classes.xml:142(para)
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr ""
+
+#: persistent_classes.xml:149(para)
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see <xref linkend=\"objectstate-transitive\"/>"
+msgstr ""
+
+#: persistent_classes.xml:156(literal)
+msgid "Session.saveOrUpdate()"
+msgstr ""
+
+#: persistent_classes.xml:161(literal)
+msgid "Session.merge()"
+msgstr ""
+
+#: persistent_classes.xml:166(para)
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr ""
+
+#: persistent_classes.xml:173(title)
+msgid "Prefer non-final classes (optional)"
+msgstr ""
+
+#: persistent_classes.xml:174(para)
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr ""
+
+#: persistent_classes.xml:179(para)
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr ""
+
+#: persistent_classes.xml:184(para)
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: persistent_classes.xml:192(title)
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr ""
+
+#: persistent_classes.xml:194(para)
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr ""
+
+#: persistent_classes.xml:204(para)
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr ""
+
+#: persistent_classes.xml:215(title)
+msgid "Implementing inheritance"
+msgstr ""
+
+#: persistent_classes.xml:217(para)
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr ""
+
+#: persistent_classes.xml:237(title)
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr ""
+
+#: persistent_classes.xml:239(para)
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr ""
+
+#: persistent_classes.xml:245(para)
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr ""
+
+#: persistent_classes.xml:252(para)
+msgid "intend to use reattachment of detached instances"
+msgstr ""
+
+#: persistent_classes.xml:258(para)
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr ""
+
+#: persistent_classes.xml:266(para)
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr ""
+
+#: persistent_classes.xml:280(para)
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr ""
+
+#: persistent_classes.xml:312(para)
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr ""
+
+#: persistent_classes.xml:322(title)
+msgid "Dynamic models"
+msgstr ""
+
+#: persistent_classes.xml:325(emphasis)
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr ""
+
+#: persistent_classes.xml:329(para)
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr ""
+
+#: persistent_classes.xml:337(para)
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr ""
+
+#: persistent_classes.xml:344(para)
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr ""
+
+#: persistent_classes.xml:384(para)
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr ""
+
+#: persistent_classes.xml:391(para)
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr ""
+
+#: persistent_classes.xml:419(para)
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr ""
+
+#: persistent_classes.xml:427(para)
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr ""
+
+#: persistent_classes.xml:446(para)
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr ""
+
+#: persistent_classes.xml:456(para)
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr ""
+
+#: persistent_classes.xml:464(title)
+msgid "Tuplizers"
+msgstr ""
+
+#: persistent_classes.xml:466(para)
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr ""
+
+#: persistent_classes.xml:481(para)
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr ""
+
+#: persistent_classes.xml:529(para)
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: persistent_classes.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/preface.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/preface.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/preface.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,72 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:33-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: preface.xml:21(title)
+msgid "Preface"
+msgstr ""
+
+#: preface.xml:23(para)
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr ""
+
+#: preface.xml:31(para)
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr ""
+
+#: preface.xml:38(para)
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr ""
+
+#: preface.xml:48(para)
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr ""
+
+#: preface.xml:55(para)
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr ""
+
+#: preface.xml:63(para)
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr ""
+
+#: preface.xml:69(para)
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr ""
+
+#: preface.xml:80(para)
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr ""
+
+#: preface.xml:90(para)
+msgid "FAQs are answered on the Hibernate website."
+msgstr ""
+
+#: preface.xml:95(para)
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr ""
+
+#: preface.xml:101(para)
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr ""
+
+#: preface.xml:109(para)
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr ""
+
+#: preface.xml:117(para)
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: preface.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/query_criteria.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/query_criteria.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/query_criteria.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,184 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:33-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: query_criteria.xml:5(title)
+msgid "Criteria Queries"
+msgstr ""
+
+#: query_criteria.xml:7(para)
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr ""
+
+#: query_criteria.xml:12(title)
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr ""
+
+#: query_criteria.xml:14(para)
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr ""
+
+#: query_criteria.xml:27(title)
+msgid "Narrowing the result set"
+msgstr ""
+
+#: query_criteria.xml:29(para)
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr ""
+
+#: query_criteria.xml:42(para)
+msgid "Restrictions may be grouped logically."
+msgstr ""
+
+#: query_criteria.xml:64(para)
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr ""
+
+#: query_criteria.xml:73(para)
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr ""
+
+#: query_criteria.xml:78(para)
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr ""
+
+#: query_criteria.xml:99(title)
+msgid "Ordering the results"
+msgstr ""
+
+#: query_criteria.xml:101(para)
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr ""
+
+#: query_criteria.xml:122(title)
+msgid "Associations"
+msgstr ""
+
+#: query_criteria.xml:124(para)
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr ""
+
+#: query_criteria.xml:135(para)
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr ""
+
+#: query_criteria.xml:141(para)
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr ""
+
+#: query_criteria.xml:151(para)
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr ""
+
+#: query_criteria.xml:156(para)
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr ""
+
+#: query_criteria.xml:178(title)
+msgid "Dynamic association fetching"
+msgstr ""
+
+#: query_criteria.xml:180(para)
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr ""
+
+#: query_criteria.xml:191(para)
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: query_criteria.xml:199(title)
+msgid "Example queries"
+msgstr ""
+
+#: query_criteria.xml:201(para)
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr ""
+
+#: query_criteria.xml:213(para)
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr ""
+
+#: query_criteria.xml:218(para)
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr ""
+
+#: query_criteria.xml:231(para)
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr ""
+
+#: query_criteria.xml:244(title)
+msgid "Projections, aggregation and grouping"
+msgstr ""
+
+#: query_criteria.xml:245(para)
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr ""
+
+#: query_criteria.xml:265(para)
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr ""
+
+#: query_criteria.xml:271(para)
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr ""
+
+#: query_criteria.xml:287(para)
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr ""
+
+#: query_criteria.xml:315(para)
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr ""
+
+#: query_criteria.xml:338(title)
+msgid "Detached queries and subqueries"
+msgstr ""
+
+#: query_criteria.xml:339(para)
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr ""
+
+#: query_criteria.xml:353(para)
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr ""
+
+#: query_criteria.xml:371(para)
+msgid "Even correlated subqueries are possible:"
+msgstr ""
+
+#: query_criteria.xml:389(title)
+msgid "Queries by natural identifier"
+msgstr ""
+
+#: query_criteria.xml:391(para)
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr ""
+
+#: query_criteria.xml:399(para)
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr ""
+
+#: query_criteria.xml:416(para)
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr ""
+
+#: query_criteria.xml:421(para)
+msgid "Next, enable the Hibernate query cache."
+msgstr ""
+
+#: query_criteria.xml:425(para)
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: query_criteria.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/query_hql.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/query_hql.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/query_hql.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,644 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:34-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: query_hql.xml:5(title)
+msgid "HQL: The Hibernate Query Language"
+msgstr ""
+
+#: query_hql.xml:7(para)
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr ""
+
+#: query_hql.xml:14(title)
+msgid "Case Sensitivity"
+msgstr ""
+
+#: query_hql.xml:16(para)
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr ""
+
+#: query_hql.xml:27(para)
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr ""
+
+#: query_hql.xml:35(title)
+msgid "The from clause"
+msgstr ""
+
+#: query_hql.xml:37(para)
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr ""
+
+#: query_hql.xml:43(para)
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr ""
+
+#: query_hql.xml:51(para)
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr ""
+
+#: query_hql.xml:59(para)
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr ""
+
+#: query_hql.xml:67(para)
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr ""
+
+#: query_hql.xml:74(para)
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr ""
+
+#: query_hql.xml:83(title)
+msgid "Associations and joins"
+msgstr ""
+
+#: query_hql.xml:85(para)
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr ""
+
+#: query_hql.xml:98(para)
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr ""
+
+#: query_hql.xml:105(literal)
+msgid "inner join"
+msgstr ""
+
+#: query_hql.xml:110(literal)
+msgid "left outer join"
+msgstr ""
+
+#: query_hql.xml:115(literal)
+msgid "right outer join"
+msgstr ""
+
+#: query_hql.xml:119(para)
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr ""
+
+#: query_hql.xml:125(para)
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr ""
+
+#: query_hql.xml:134(para)
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr ""
+
+#: query_hql.xml:143(para)
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: query_hql.xml:155(para)
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr ""
+
+#: query_hql.xml:168(para)
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr ""
+
+#: query_hql.xml:183(para)
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr ""
+
+#: query_hql.xml:195(title)
+msgid "Forms of join syntax"
+msgstr ""
+
+#: query_hql.xml:197(para)
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr ""
+
+#: query_hql.xml:201(para)
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr ""
+
+#: query_hql.xml:206(para)
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr ""
+
+#: query_hql.xml:217(title)
+msgid "Refering to identifier property"
+msgstr ""
+
+#: query_hql.xml:219(para)
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr ""
+
+#: query_hql.xml:224(para)
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr ""
+
+#: query_hql.xml:231(para)
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr ""
+
+#: query_hql.xml:237(para)
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr ""
+
+#: query_hql.xml:244(para)
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal><emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr ""
+
+#: query_hql.xml:253(title)
+msgid "The select clause"
+msgstr ""
+
+#: query_hql.xml:255(para)
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr ""
+
+#: query_hql.xml:264(para)
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr ""
+
+#: query_hql.xml:271(para)
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+
+#: query_hql.xml:280(para)
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr ""
+
+#: query_hql.xml:290(para)
+msgid "or as a <literal>List</literal>,"
+msgstr ""
+
+#: query_hql.xml:299(para)
+msgid "or as an actual typesafe Java object,"
+msgstr ""
+
+#: query_hql.xml:308(para)
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr ""
+
+#: query_hql.xml:312(para)
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr ""
+
+#: query_hql.xml:319(para)
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr ""
+
+#: query_hql.xml:326(para)
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr ""
+
+#: query_hql.xml:333(title)
+msgid "Aggregate functions"
+msgstr ""
+
+#: query_hql.xml:335(para)
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr ""
+
+#. NO LONGER SUPPORTED
+#. <para>
+#. Collections may also appear inside aggregate functions in the <literal>select</literal>
+#. clause.
+#. </para>
+#.
+#. <programlisting><![CDATA[select cat, count( elements(cat.kittens) )
+#. from Cat cat group by cat]]></programlisting>
+#: query_hql.xml:352(para)
+msgid "The supported aggregate functions are"
+msgstr ""
+
+#: query_hql.xml:359(literal)
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr ""
+
+#: query_hql.xml:364(literal)
+msgid "count(*)"
+msgstr ""
+
+#: query_hql.xml:369(literal)
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr ""
+
+#: query_hql.xml:374(para)
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr ""
+
+#: query_hql.xml:386(para)
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr ""
+
+#: query_hql.xml:398(title)
+msgid "Polymorphic queries"
+msgstr ""
+
+#: query_hql.xml:400(para)
+msgid "A query like:"
+msgstr ""
+
+#: query_hql.xml:406(para)
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr ""
+
+#: query_hql.xml:416(para)
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr ""
+
+#: query_hql.xml:423(para)
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr ""
+
+#: query_hql.xml:432(title)
+msgid "The where clause"
+msgstr ""
+
+#: query_hql.xml:434(para)
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr ""
+
+#: query_hql.xml:441(para)
+msgid "If there is an alias, use a qualified property name:"
+msgstr ""
+
+#: query_hql.xml:447(para)
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr ""
+
+#: query_hql.xml:455(para)
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr ""
+
+#: query_hql.xml:466(para)
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr ""
+
+#: query_hql.xml:474(para)
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr ""
+
+#: query_hql.xml:478(para)
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr ""
+
+#: query_hql.xml:489(para)
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr ""
+
+#: query_hql.xml:499(para)
+msgid "The second query is efficient. No table join is required!"
+msgstr ""
+
+#: query_hql.xml:503(para)
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr ""
+
+#: query_hql.xml:518(para)
+msgid "Once again, the second query requires no table join."
+msgstr ""
+
+#: query_hql.xml:522(para)
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr ""
+
+#: query_hql.xml:530(para)
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr ""
+
+#: query_hql.xml:535(para)
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr ""
+
+#: query_hql.xml:544(para)
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr ""
+
+#: query_hql.xml:552(title)
+msgid "Expressions"
+msgstr ""
+
+#: query_hql.xml:554(para)
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr ""
+
+#: query_hql.xml:561(para)
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr ""
+
+#: query_hql.xml:566(para)
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr ""
+
+#: query_hql.xml:571(para)
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr ""
+
+#: query_hql.xml:576(para)
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr ""
+
+#: query_hql.xml:581(para)
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr ""
+
+#: query_hql.xml:594(para)
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr ""
+
+#: query_hql.xml:600(para)
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr ""
+
+#: query_hql.xml:605(para)
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr ""
+
+#: query_hql.xml:611(para)
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr ""
+
+#: query_hql.xml:618(para)
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr ""
+
+#: query_hql.xml:624(para)
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr ""
+
+#: query_hql.xml:629(para)
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr ""
+
+#: query_hql.xml:635(para)
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr ""
+
+#: query_hql.xml:643(para)
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr ""
+
+#: query_hql.xml:649(para)
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr ""
+
+#: query_hql.xml:657(para)
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr ""
+
+#: query_hql.xml:663(para)
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr ""
+
+#: query_hql.xml:668(para)
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr ""
+
+#: query_hql.xml:673(para)
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr ""
+
+#: query_hql.xml:679(para)
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr ""
+
+#: query_hql.xml:685(para)
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr ""
+
+#: query_hql.xml:693(para)
+msgid "and the negated forms may be written"
+msgstr ""
+
+#: query_hql.xml:701(para)
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr ""
+
+#: query_hql.xml:706(para)
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr ""
+
+#: query_hql.xml:713(para)
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr ""
+
+#: query_hql.xml:720(para)
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr ""
+
+#: query_hql.xml:729(para)
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr ""
+
+#: query_hql.xml:743(para)
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr ""
+
+#: query_hql.xml:761(para)
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr ""
+
+#: query_hql.xml:768(para)
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr ""
+
+#: query_hql.xml:785(para)
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr ""
+
+#: query_hql.xml:792(para)
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+
+#: query_hql.xml:801(para)
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr ""
+
+#: query_hql.xml:807(para)
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr ""
+
+#: query_hql.xml:820(para)
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr ""
+
+#: query_hql.xml:845(title)
+msgid "The order by clause"
+msgstr ""
+
+#: query_hql.xml:847(para)
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+
+#: query_hql.xml:854(para)
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr ""
+
+#: query_hql.xml:861(title)
+msgid "The group by clause"
+msgstr ""
+
+#: query_hql.xml:863(para)
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr ""
+
+#: query_hql.xml:875(para)
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr ""
+
+#: query_hql.xml:884(para)
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+
+#: query_hql.xml:897(para)
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr ""
+
+#: query_hql.xml:909(title)
+msgid "Subqueries"
+msgstr ""
+
+#: query_hql.xml:911(para)
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr ""
+
+#: query_hql.xml:940(para)
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr ""
+
+#: query_hql.xml:944(para)
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr ""
+
+#: query_hql.xml:952(title)
+msgid "HQL examples"
+msgstr ""
+
+#: query_hql.xml:954(para)
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr ""
+
+#: query_hql.xml:960(para)
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr ""
+
+#: query_hql.xml:988(para)
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr ""
+
+#: query_hql.xml:1007(para)
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr ""
+
+#: query_hql.xml:1031(para)
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr ""
+
+#: query_hql.xml:1044(para)
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr ""
+
+#: query_hql.xml:1060(para)
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr ""
+
+#: query_hql.xml:1075(title)
+msgid "Bulk update and delete"
+msgstr ""
+
+#: query_hql.xml:1077(para)
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr ""
+
+#: query_hql.xml:1085(title)
+msgid "Tips & Tricks"
+msgstr ""
+
+#: query_hql.xml:1087(para)
+msgid "You can count the number of query results without actually returning them:"
+msgstr ""
+
+#: query_hql.xml:1093(para)
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr ""
+
+#: query_hql.xml:1103(para)
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr ""
+
+#: query_hql.xml:1110(para)
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr ""
+
+#: query_hql.xml:1120(para)
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr ""
+
+#: query_hql.xml:1131(para)
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr ""
+
+#: query_hql.xml:1139(para)
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+
+#: query_hql.xml:1148(para)
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+
+#: query_hql.xml:1155(para)
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+
+#: query_hql.xml:1164(title)
+msgid "Components"
+msgstr ""
+
+#: query_hql.xml:1166(para)
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: query_hql.xml:1174(para)
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: query_hql.xml:1182(para)
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: query_hql.xml:1189(para)
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\">row value constructors</xref>."
+msgstr ""
+
+#: query_hql.xml:1195(title)
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: query_hql.xml:1197(para)
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: query_hql.xml:1206(para)
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: query_hql.xml:1213(para)
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: query_hql.xml:1219(para)
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: query_hql.xml:1229(para)
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: query_hql.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/query_sql.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/query_sql.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/query_sql.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,476 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:34-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: query_sql.xml:5(title)
+msgid "Native SQL"
+msgstr ""
+
+#: query_sql.xml:7(para)
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr ""
+
+#: query_sql.xml:13(para)
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr ""
+
+#: query_sql.xml:17(title)
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr ""
+
+#: query_sql.xml:19(para)
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr ""
+
+#: query_sql.xml:25(title)
+msgid "Scalar queries"
+msgstr ""
+
+#: query_sql.xml:27(para)
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr ""
+
+#: query_sql.xml:34(para)
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr ""
+
+#: query_sql.xml:39(para)
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr ""
+
+#: query_sql.xml:49(para) query_sql.xml:101(para) query_sql.xml:195(para) query_sql.xml:354(para)
+msgid "This query specified:"
+msgstr ""
+
+#: query_sql.xml:53(para) query_sql.xml:105(para) query_sql.xml:358(para)
+msgid "the SQL query string"
+msgstr ""
+
+#: query_sql.xml:57(para)
+msgid "the columns and types to return"
+msgstr ""
+
+#: query_sql.xml:61(para)
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr ""
+
+#: query_sql.xml:69(para)
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr ""
+
+#: query_sql.xml:78(para)
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr ""
+
+#: query_sql.xml:82(para)
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr ""
+
+#: query_sql.xml:90(title)
+msgid "Entity queries"
+msgstr ""
+
+#: query_sql.xml:92(para)
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr ""
+
+#: query_sql.xml:109(para)
+msgid "the entity returned by the query"
+msgstr ""
+
+#: query_sql.xml:113(para)
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr ""
+
+#: query_sql.xml:117(para)
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr ""
+
+#: query_sql.xml:128(para)
+msgid "This will allow cat.getDog() to function properly."
+msgstr ""
+
+#: query_sql.xml:132(title)
+msgid "Handling associations and collections"
+msgstr ""
+
+#: query_sql.xml:134(para)
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr ""
+
+#: query_sql.xml:144(para)
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr ""
+
+#: query_sql.xml:157(p)
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr ""
+
+#: query_sql.xml:165(title)
+msgid "Returning multiple entities"
+msgstr ""
+
+#: query_sql.xml:167(para)
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr ""
+
+#: query_sql.xml:172(para)
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr ""
+
+#: query_sql.xml:180(para)
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr ""
+
+#: query_sql.xml:187(para)
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr ""
+
+#: query_sql.xml:199(para)
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr ""
+
+#: query_sql.xml:204(para)
+msgid "the entities returned by the query"
+msgstr ""
+
+#: query_sql.xml:208(para)
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr ""
+
+#: query_sql.xml:227(title)
+msgid "Alias and property references"
+msgstr ""
+
+#: query_sql.xml:229(para)
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr ""
+
+#: query_sql.xml:234(para)
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr ""
+
+#: query_sql.xml:240(title)
+msgid "Alias injection names"
+msgstr ""
+
+#: query_sql.xml:251(entry)
+msgid "Description"
+msgstr ""
+
+#: query_sql.xml:253(entry)
+msgid "Syntax"
+msgstr ""
+
+#: query_sql.xml:255(entry)
+msgid "Example"
+msgstr ""
+
+#: query_sql.xml:261(entry)
+msgid "A simple property"
+msgstr ""
+
+#: query_sql.xml:263(literal)
+msgid "{[aliasname].[propertyname]"
+msgstr ""
+
+#: query_sql.xml:265(literal)
+msgid "A_NAME as {item.name}"
+msgstr ""
+
+#: query_sql.xml:269(entry)
+msgid "A composite property"
+msgstr ""
+
+#: query_sql.xml:271(literal)
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr ""
+
+#: query_sql.xml:273(literal)
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr ""
+
+#: query_sql.xml:278(entry)
+msgid "Discriminator of an entity"
+msgstr ""
+
+#: query_sql.xml:280(literal)
+msgid "{[aliasname].class}"
+msgstr ""
+
+#: query_sql.xml:282(literal)
+msgid "DISC as {item.class}"
+msgstr ""
+
+#: query_sql.xml:286(entry)
+msgid "All properties of an entity"
+msgstr ""
+
+#: query_sql.xml:288(literal) query_sql.xml:336(literal)
+msgid "{[aliasname].*}"
+msgstr ""
+
+#: query_sql.xml:290(literal)
+msgid "{item.*}"
+msgstr ""
+
+#: query_sql.xml:294(entry)
+msgid "A collection key"
+msgstr ""
+
+#: query_sql.xml:296(literal)
+msgid "{[aliasname].key}"
+msgstr ""
+
+#: query_sql.xml:298(literal)
+msgid "ORGID as {coll.key}"
+msgstr ""
+
+#: query_sql.xml:302(entry)
+msgid "The id of an collection"
+msgstr ""
+
+#: query_sql.xml:304(literal)
+msgid "{[aliasname].id}"
+msgstr ""
+
+#: query_sql.xml:306(literal)
+msgid "EMPID as {coll.id}"
+msgstr ""
+
+#: query_sql.xml:310(entry)
+msgid "The element of an collection"
+msgstr ""
+
+#: query_sql.xml:312(literal)
+msgid "{[aliasname].element}"
+msgstr ""
+
+#: query_sql.xml:314(literal)
+msgid "XID as {coll.element}"
+msgstr ""
+
+#: query_sql.xml:318(entry)
+msgid "roperty of the element in the collection"
+msgstr ""
+
+#: query_sql.xml:320(literal)
+msgid "{[aliasname].element.[propertyname]}"
+msgstr ""
+
+#: query_sql.xml:322(literal)
+msgid "NAME as {coll.element.name}"
+msgstr ""
+
+#: query_sql.xml:326(entry)
+msgid "All properties of the element in the collection"
+msgstr ""
+
+#: query_sql.xml:328(literal)
+msgid "{[aliasname].element.*}"
+msgstr ""
+
+#: query_sql.xml:330(literal)
+msgid "{coll.element.*}"
+msgstr ""
+
+#: query_sql.xml:334(entry)
+msgid "All properties of the the collection"
+msgstr ""
+
+#: query_sql.xml:338(literal)
+msgid "{coll.*}"
+msgstr ""
+
+#: query_sql.xml:347(title)
+msgid "Returning non-managed entities"
+msgstr ""
+
+#: query_sql.xml:349(para)
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr ""
+
+#: query_sql.xml:362(para)
+msgid "a result transformer"
+msgstr ""
+
+#: query_sql.xml:366(para)
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr ""
+
+#: query_sql.xml:373(title)
+msgid "Handling inheritance"
+msgstr ""
+
+#: query_sql.xml:375(para)
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr ""
+
+#: query_sql.xml:381(title)
+msgid "Parameters"
+msgstr ""
+
+#: query_sql.xml:383(para)
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr ""
+
+#: query_sql.xml:398(title)
+msgid "Named SQL queries"
+msgstr ""
+
+#: query_sql.xml:400(para)
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr ""
+
+#: query_sql.xml:419(para)
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr ""
+
+#: query_sql.xml:440(para)
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr ""
+
+#: query_sql.xml:452(para)
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr ""
+
+#: query_sql.xml:476(para)
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr ""
+
+#: query_sql.xml:486(title)
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr ""
+
+#: query_sql.xml:489(para)
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr ""
+
+#: query_sql.xml:507(para)
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr ""
+
+#: query_sql.xml:528(para)
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr ""
+
+#: query_sql.xml:533(para)
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr ""
+
+#: query_sql.xml:539(title)
+msgid "Using stored procedures for querying"
+msgstr ""
+
+#: query_sql.xml:541(para)
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr ""
+
+#: query_sql.xml:560(para)
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr ""
+
+#: query_sql.xml:579(para)
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr ""
+
+#: query_sql.xml:584(title)
+msgid "Rules/limitations for using stored procedures"
+msgstr ""
+
+#: query_sql.xml:586(para)
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr ""
+
+#: query_sql.xml:593(para)
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr ""
+
+#: query_sql.xml:596(para)
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr ""
+
+#: query_sql.xml:601(para)
+msgid "For Oracle the following rules apply:"
+msgstr ""
+
+#: query_sql.xml:605(para)
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr ""
+
+#: query_sql.xml:614(para)
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr ""
+
+#: query_sql.xml:618(para)
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr ""
+
+#: query_sql.xml:626(para)
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr ""
+
+#: query_sql.xml:636(title)
+msgid "Custom SQL for create, update and delete"
+msgstr ""
+
+#: query_sql.xml:638(para)
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr ""
+
+#: query_sql.xml:656(para)
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr ""
+
+#: query_sql.xml:660(para)
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr ""
+
+#: query_sql.xml:673(para)
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr ""
+
+#: query_sql.xml:676(para)
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr ""
+
+#: query_sql.xml:683(para)
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr ""
+
+#: query_sql.xml:705(title)
+msgid "Custom SQL for loading"
+msgstr ""
+
+#: query_sql.xml:707(para)
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr ""
+
+#: query_sql.xml:718(para)
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr ""
+
+#: query_sql.xml:729(para)
+msgid "This even works with stored procedures."
+msgstr ""
+
+#: query_sql.xml:731(para)
+msgid "You may even define a query for collection loading:"
+msgstr ""
+
+#: query_sql.xml:747(para)
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: query_sql.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/session_api.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/session_api.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/session_api.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,636 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:34-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: session_api.xml:5(title)
+msgid "Working with objects"
+msgstr ""
+
+#: session_api.xml:7(para)
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr ""
+
+#: session_api.xml:16(para)
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr ""
+
+#: session_api.xml:24(title)
+msgid "Hibernate object states"
+msgstr ""
+
+#: session_api.xml:26(para)
+msgid "Hibernate defines and supports the following object states:"
+msgstr ""
+
+#: session_api.xml:32(para)
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr ""
+
+#: session_api.xml:44(para)
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr ""
+
+#: session_api.xml:55(para)
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr ""
+
+#: session_api.xml:69(para)
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr ""
+
+#: session_api.xml:77(title)
+msgid "Making objects persistent"
+msgstr ""
+
+#: session_api.xml:79(para)
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr ""
+
+#: session_api.xml:92(para)
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr ""
+
+#: session_api.xml:104(para)
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr ""
+
+#: session_api.xml:115(para)
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+
+#: session_api.xml:125(para)
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr ""
+
+#: session_api.xml:138(para)
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr ""
+
+#: session_api.xml:148(para)
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr ""
+
+#: session_api.xml:159(title)
+msgid "Loading an object"
+msgstr ""
+
+#: session_api.xml:161(para)
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+
+#: session_api.xml:174(para)
+msgid "Alternatively, you can load state into a given instance:"
+msgstr ""
+
+#: session_api.xml:183(para)
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+
+#: session_api.xml:194(para)
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr ""
+
+#: session_api.xml:207(para)
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr ""
+
+#: session_api.xml:214(para)
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+
+#: session_api.xml:221(para)
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr ""
+
+#: session_api.xml:231(para)
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr ""
+
+#: session_api.xml:241(title)
+msgid "Querying"
+msgstr ""
+
+#: session_api.xml:243(para)
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr ""
+
+#: session_api.xml:253(title)
+msgid "Executing queries"
+msgstr ""
+
+#: session_api.xml:255(para)
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr ""
+
+#: session_api.xml:286(para)
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr ""
+
+#: session_api.xml:298(title)
+msgid "Iterating results"
+msgstr ""
+
+#: session_api.xml:300(para)
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr ""
+
+#: session_api.xml:327(title)
+msgid "Queries that return tuples"
+msgstr ""
+
+#: session_api.xml:329(para)
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr ""
+
+#: session_api.xml:349(title)
+msgid "Scalar results"
+msgstr ""
+
+#: session_api.xml:351(para)
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr ""
+
+#: session_api.xml:374(title)
+msgid "Bind parameters"
+msgstr ""
+
+#: session_api.xml:376(para)
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr ""
+
+#: session_api.xml:386(para)
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr ""
+
+#: session_api.xml:392(para)
+msgid "they may occur multiple times in the same query"
+msgstr ""
+
+#: session_api.xml:397(para)
+msgid "they are self-documenting"
+msgstr ""
+
+#: session_api.xml:424(title)
+msgid "Pagination"
+msgstr ""
+
+#: session_api.xml:426(para)
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr ""
+
+#: session_api.xml:437(para)
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr ""
+
+#: session_api.xml:445(title)
+msgid "Scrollable iteration"
+msgstr ""
+
+#: session_api.xml:447(para)
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr ""
+
+#: session_api.xml:476(para)
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr ""
+
+#: session_api.xml:485(title)
+msgid "Externalizing named queries"
+msgstr ""
+
+#: session_api.xml:487(para)
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr ""
+
+#: session_api.xml:499(para)
+msgid "Parameter binding and executing is done programatically:"
+msgstr ""
+
+#: session_api.xml:508(para)
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr ""
+
+#: session_api.xml:514(para)
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr ""
+
+#: session_api.xml:527(title)
+msgid "Filtering collections"
+msgstr ""
+
+#: session_api.xml:528(para)
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr ""
+
+#: session_api.xml:541(para)
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr ""
+
+#: session_api.xml:547(para)
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr ""
+
+#: session_api.xml:557(para)
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr ""
+
+#: session_api.xml:570(title)
+msgid "Criteria queries"
+msgstr ""
+
+#: session_api.xml:572(para)
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr ""
+
+#: session_api.xml:583(para)
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr ""
+
+#: session_api.xml:591(title)
+msgid "Queries in native SQL"
+msgstr ""
+
+#: session_api.xml:593(para)
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr ""
+
+#: session_api.xml:612(para)
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr ""
+
+#: session_api.xml:623(title)
+msgid "Modifying persistent objects"
+msgstr ""
+
+#: session_api.xml:625(para)
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr ""
+
+#: session_api.xml:640(para)
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr ""
+
+#: session_api.xml:649(literal)
+msgid "UPDATE"
+msgstr ""
+
+#: session_api.xml:649(literal)
+msgid "DELETE"
+msgstr ""
+
+#: session_api.xml:650(emphasis)
+msgid "state management"
+msgstr ""
+
+#: session_api.xml:651(emphasis)
+msgid "statements"
+msgstr ""
+
+#: session_api.xml:652(literal)
+msgid "Connection"
+msgstr ""
+
+#: session_api.xml:653(literal)
+msgid "session.connection()"
+msgstr ""
+
+#: session_api.xml:648(emphasis)
+msgid "Note that Hibernate does not offer its own API for direct execution of <placeholder-1/> or <placeholder-2/> statements. Hibernate is a <placeholder-3/> service, you don't have to think in <placeholder-4/> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <placeholder-5/> at any time by calling <placeholder-6/>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr ""
+
+#: session_api.xml:663(title)
+msgid "Modifying detached objects"
+msgstr ""
+
+#: session_api.xml:665(para)
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr ""
+
+#: session_api.xml:672(para)
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr ""
+
+#: session_api.xml:690(para)
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr ""
+
+#: session_api.xml:696(para)
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr ""
+
+#: session_api.xml:705(para)
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr ""
+
+#: session_api.xml:712(para)
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr ""
+
+#: session_api.xml:724(para)
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr ""
+
+#: session_api.xml:731(para)
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr ""
+
+#: session_api.xml:738(title)
+msgid "Automatic state detection"
+msgstr ""
+
+#: session_api.xml:740(para)
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr ""
+
+#: session_api.xml:758(para)
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr ""
+
+#: session_api.xml:766(para)
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr ""
+
+#: session_api.xml:773(para)
+msgid "the application loads an object in the first session"
+msgstr ""
+
+#: session_api.xml:778(para)
+msgid "the object is passed up to the UI tier"
+msgstr ""
+
+#: session_api.xml:783(para)
+msgid "some modifications are made to the object"
+msgstr ""
+
+#: session_api.xml:788(para)
+msgid "the object is passed back down to the business logic tier"
+msgstr ""
+
+#: session_api.xml:793(para)
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr ""
+
+#: session_api.xml:800(para)
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr ""
+
+#: session_api.xml:806(para)
+msgid "if the object is already persistent in this session, do nothing"
+msgstr ""
+
+#: session_api.xml:811(para)
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr ""
+
+#: session_api.xml:817(para)
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr ""
+
+#: session_api.xml:822(para)
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: session_api.xml:828(para)
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: session_api.xml:836(para)
+msgid "otherwise <literal>update()</literal> the object"
+msgstr ""
+
+#: session_api.xml:842(para)
+msgid "and <literal>merge()</literal> is very different:"
+msgstr ""
+
+#: session_api.xml:848(para)
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr ""
+
+#: session_api.xml:855(para)
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr ""
+
+#: session_api.xml:861(para)
+msgid "the persistent instance is returned"
+msgstr ""
+
+#: session_api.xml:866(para)
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr ""
+
+#: session_api.xml:876(title)
+msgid "Deleting persistent objects"
+msgstr ""
+
+#: session_api.xml:878(para)
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr ""
+
+#: session_api.xml:887(para)
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr ""
+
+#: session_api.xml:898(title)
+msgid "Replicating object between two different datastores"
+msgstr ""
+
+#: session_api.xml:900(para)
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr ""
+
+#: session_api.xml:920(para)
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr ""
+
+#: session_api.xml:927(para)
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr ""
+
+#: session_api.xml:933(para)
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr ""
+
+#: session_api.xml:939(para)
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr ""
+
+#: session_api.xml:945(para)
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr ""
+
+#: session_api.xml:953(para)
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr ""
+
+#: session_api.xml:962(title)
+msgid "Flushing the Session"
+msgstr ""
+
+#: session_api.xml:964(para)
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr ""
+
+#: session_api.xml:973(para)
+msgid "before some query executions"
+msgstr ""
+
+#: session_api.xml:978(para)
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr ""
+
+#: session_api.xml:983(para)
+msgid "from <literal>Session.flush()</literal>"
+msgstr ""
+
+#: session_api.xml:989(para)
+msgid "The SQL statements are issued in the following order"
+msgstr ""
+
+#: session_api.xml:995(para)
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr ""
+
+#: session_api.xml:1001(para)
+msgid "all entity updates"
+msgstr ""
+
+#: session_api.xml:1006(para)
+msgid "all collection deletions"
+msgstr ""
+
+#: session_api.xml:1011(para)
+msgid "all collection element deletions, updates and insertions"
+msgstr ""
+
+#: session_api.xml:1016(para)
+msgid "all collection insertions"
+msgstr ""
+
+#: session_api.xml:1021(para)
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr ""
+
+#: session_api.xml:1028(para)
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr ""
+
+#: session_api.xml:1033(para)
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr ""
+
+#: session_api.xml:1041(para)
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr ""
+
+#: session_api.xml:1066(para)
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr ""
+
+#: session_api.xml:1075(title)
+msgid "Transitive persistence"
+msgstr ""
+
+#: session_api.xml:1077(para)
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr ""
+
+#: session_api.xml:1083(para)
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr ""
+
+#: session_api.xml:1094(para)
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr ""
+
+#: session_api.xml:1103(para)
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr ""
+
+#: session_api.xml:1114(para)
+msgid "Cascade styles my be combined:"
+msgstr ""
+
+#: session_api.xml:1120(para)
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr ""
+
+#: session_api.xml:1126(para)
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr ""
+
+#: session_api.xml:1133(para)
+msgid "Recommendations:"
+msgstr ""
+
+#: session_api.xml:1139(para)
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr ""
+
+#: session_api.xml:1147(para)
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr ""
+
+#: session_api.xml:1154(para)
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr ""
+
+#: session_api.xml:1162(para)
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr ""
+
+#: session_api.xml:1168(para)
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr ""
+
+#: session_api.xml:1179(para)
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr ""
+
+#: session_api.xml:1185(para)
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr ""
+
+#: session_api.xml:1191(para)
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: session_api.xml:1197(para)
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: session_api.xml:1203(para)
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr ""
+
+#: session_api.xml:1208(para)
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr ""
+
+#: session_api.xml:1217(para)
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr ""
+
+#: session_api.xml:1229(title)
+msgid "Using metadata"
+msgstr ""
+
+#: session_api.xml:1231(para)
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+
+#: session_api.xml:1238(para)
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: session_api.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/toolset_guide.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/toolset_guide.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/toolset_guide.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,548 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:34-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: toolset_guide.xml:5(title)
+msgid "Toolset Guide"
+msgstr ""
+
+#: toolset_guide.xml:7(para)
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr ""
+
+#: toolset_guide.xml:12(para)
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr ""
+
+#: toolset_guide.xml:18(para)
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr ""
+
+#: toolset_guide.xml:23(para)
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr ""
+
+#: toolset_guide.xml:30(para)
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr ""
+
+#: toolset_guide.xml:38(emphasis)
+msgid "Ant Tasks:"
+msgstr ""
+
+#: toolset_guide.xml:43(para)
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr ""
+
+#: toolset_guide.xml:48(para)
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr ""
+
+#: toolset_guide.xml:55(title)
+msgid "Automatic schema generation"
+msgstr ""
+
+#: toolset_guide.xml:57(para)
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr ""
+
+#: toolset_guide.xml:64(para)
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr ""
+
+#: toolset_guide.xml:70(para)
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr ""
+
+#: toolset_guide.xml:75(title)
+msgid "Customizing the schema"
+msgstr ""
+
+#: toolset_guide.xml:77(para)
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr ""
+
+#: toolset_guide.xml:87(para)
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr ""
+
+#: toolset_guide.xml:97(para)
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr ""
+
+#: toolset_guide.xml:108(para)
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr ""
+
+#: toolset_guide.xml:117(para)
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr ""
+
+#: toolset_guide.xml:124(para)
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr ""
+
+#: toolset_guide.xml:135(para)
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr ""
+
+#: toolset_guide.xml:149(para)
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr ""
+
+#: toolset_guide.xml:158(para)
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr ""
+
+#: toolset_guide.xml:173(title)
+msgid "Summary"
+msgstr ""
+
+#: toolset_guide.xml:180(entry)
+msgid "Attribute"
+msgstr ""
+
+#: toolset_guide.xml:181(entry)
+msgid "Values"
+msgstr ""
+
+#: toolset_guide.xml:182(entry)
+msgid "Interpretation"
+msgstr ""
+
+#: toolset_guide.xml:187(literal)
+msgid "length"
+msgstr ""
+
+#: toolset_guide.xml:188(entry) toolset_guide.xml:193(entry) toolset_guide.xml:198(entry)
+msgid "number"
+msgstr ""
+
+#: toolset_guide.xml:189(entry)
+msgid "column length"
+msgstr ""
+
+#: toolset_guide.xml:192(literal)
+msgid "precision"
+msgstr ""
+
+#: toolset_guide.xml:194(entry)
+msgid "column decimal precision"
+msgstr ""
+
+#: toolset_guide.xml:197(literal)
+msgid "scale"
+msgstr ""
+
+#: toolset_guide.xml:199(entry)
+msgid "column decimal scale"
+msgstr ""
+
+#: toolset_guide.xml:202(literal)
+msgid "not-null"
+msgstr ""
+
+#: toolset_guide.xml:203(literal) toolset_guide.xml:208(literal)
+msgid "true|false"
+msgstr ""
+
+#: toolset_guide.xml:204(entry)
+msgid "specfies that the column should be non-nullable"
+msgstr ""
+
+#: toolset_guide.xml:207(literal)
+msgid "unique"
+msgstr ""
+
+#: toolset_guide.xml:209(entry)
+msgid "specifies that the column should have a unique constraint"
+msgstr ""
+
+#: toolset_guide.xml:212(literal)
+msgid "index"
+msgstr ""
+
+#: toolset_guide.xml:213(literal)
+msgid "index_name"
+msgstr ""
+
+#: toolset_guide.xml:214(entry)
+msgid "specifies the name of a (multi-column) index"
+msgstr ""
+
+#: toolset_guide.xml:217(literal)
+msgid "unique-key"
+msgstr ""
+
+#: toolset_guide.xml:218(literal)
+msgid "unique_key_name"
+msgstr ""
+
+#: toolset_guide.xml:219(entry)
+msgid "specifies the name of a multi-column unique constraint"
+msgstr ""
+
+#: toolset_guide.xml:222(literal)
+msgid "foreign-key"
+msgstr ""
+
+#: toolset_guide.xml:223(literal)
+msgid "foreign_key_name"
+msgstr ""
+
+#: toolset_guide.xml:226(literal)
+msgid "<one-to-one>"
+msgstr ""
+
+#: toolset_guide.xml:227(literal)
+msgid "<many-to-one>"
+msgstr ""
+
+#: toolset_guide.xml:227(literal)
+msgid "<key>"
+msgstr ""
+
+#: toolset_guide.xml:228(literal)
+msgid "<many-to-many>"
+msgstr ""
+
+#: toolset_guide.xml:229(literal)
+msgid "inverse=\"true\""
+msgstr ""
+
+#: toolset_guide.xml:230(literal)
+msgid "SchemaExport"
+msgstr ""
+
+#: toolset_guide.xml:224(entry)
+msgid "specifies the name of the foreign key constraint generated for an association, for a <placeholder-1/>, <placeholder-2/>, <placeholder-3/>, or <placeholder-4/> mapping element. Note that <placeholder-5/> sides will not be considered by <placeholder-6/>."
+msgstr ""
+
+#: toolset_guide.xml:234(literal)
+msgid "sql-type"
+msgstr ""
+
+#: toolset_guide.xml:235(literal)
+msgid "SQL column type"
+msgstr ""
+
+#: toolset_guide.xml:238(literal)
+msgid "<column>"
+msgstr ""
+
+#: toolset_guide.xml:236(entry)
+msgid "overrides the default column type (attribute of <placeholder-1/> element only)"
+msgstr ""
+
+#: toolset_guide.xml:242(literal)
+msgid "default"
+msgstr ""
+
+#: toolset_guide.xml:243(entry) toolset_guide.xml:250(entry)
+msgid "SQL expression"
+msgstr ""
+
+#: toolset_guide.xml:244(entry)
+msgid "specify a default value for the column"
+msgstr ""
+
+#: toolset_guide.xml:249(literal)
+msgid "check"
+msgstr ""
+
+#: toolset_guide.xml:251(entry)
+msgid "create an SQL check constraint on either column or table"
+msgstr ""
+
+#: toolset_guide.xml:259(para)
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr ""
+
+#: toolset_guide.xml:275(para)
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr ""
+
+#: toolset_guide.xml:284(title)
+msgid "Running the tool"
+msgstr ""
+
+#: toolset_guide.xml:286(para)
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr ""
+
+#: toolset_guide.xml:292(literal) toolset_guide.xml:459(literal) toolset_guide.xml:541(literal)
+msgid "java -cp"
+msgstr ""
+
+#: toolset_guide.xml:292(emphasis) toolset_guide.xml:459(emphasis) toolset_guide.xml:541(emphasis)
+msgid "hibernate_classpaths"
+msgstr ""
+
+#: toolset_guide.xml:293(literal)
+msgid "org.hibernate.tool.hbm2ddl.SchemaExport"
+msgstr ""
+
+#: toolset_guide.xml:293(emphasis) toolset_guide.xml:460(emphasis) toolset_guide.xml:542(emphasis)
+msgid "options mapping_files"
+msgstr ""
+
+#: toolset_guide.xml:297(title)
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr ""
+
+#: toolset_guide.xml:303(entry) toolset_guide.xml:470(entry) toolset_guide.xml:552(entry)
+msgid "Option"
+msgstr ""
+
+#: toolset_guide.xml:304(entry) toolset_guide.xml:392(entry) toolset_guide.xml:471(entry) toolset_guide.xml:553(entry)
+msgid "Description"
+msgstr ""
+
+#: toolset_guide.xml:309(literal) toolset_guide.xml:476(literal)
+msgid "--quiet"
+msgstr ""
+
+#: toolset_guide.xml:310(entry) toolset_guide.xml:477(entry)
+msgid "don't output the script to stdout"
+msgstr ""
+
+#: toolset_guide.xml:313(literal)
+msgid "--drop"
+msgstr ""
+
+#: toolset_guide.xml:314(entry)
+msgid "only drop the tables"
+msgstr ""
+
+#: toolset_guide.xml:317(literal)
+msgid "--create"
+msgstr ""
+
+#: toolset_guide.xml:318(entry)
+msgid "only create the tables"
+msgstr ""
+
+#: toolset_guide.xml:321(literal) toolset_guide.xml:480(literal)
+msgid "--text"
+msgstr ""
+
+#: toolset_guide.xml:322(entry)
+msgid "don't export to the database"
+msgstr ""
+
+#: toolset_guide.xml:325(literal)
+msgid "--output=my_schema.ddl"
+msgstr ""
+
+#: toolset_guide.xml:326(entry)
+msgid "output the ddl script to a file"
+msgstr ""
+
+#: toolset_guide.xml:329(literal) toolset_guide.xml:484(literal) toolset_guide.xml:558(literal)
+msgid "--naming=eg.MyNamingStrategy"
+msgstr ""
+
+#: toolset_guide.xml:330(literal) toolset_guide.xml:485(literal) toolset_guide.xml:559(literal)
+msgid "NamingStrategy"
+msgstr ""
+
+#: toolset_guide.xml:330(entry) toolset_guide.xml:485(entry) toolset_guide.xml:559(entry)
+msgid "select a <placeholder-1/>"
+msgstr ""
+
+#: toolset_guide.xml:333(literal) toolset_guide.xml:492(literal) toolset_guide.xml:566(literal)
+msgid "--config=hibernate.cfg.xml"
+msgstr ""
+
+#: toolset_guide.xml:334(entry)
+msgid "read Hibernate configuration from an XML file"
+msgstr ""
+
+#: toolset_guide.xml:337(literal) toolset_guide.xml:488(literal) toolset_guide.xml:562(literal)
+msgid "--properties=hibernate.properties"
+msgstr ""
+
+#: toolset_guide.xml:338(entry) toolset_guide.xml:489(entry) toolset_guide.xml:563(entry)
+msgid "read database properties from a file"
+msgstr ""
+
+#: toolset_guide.xml:341(literal)
+msgid "--format"
+msgstr ""
+
+#: toolset_guide.xml:342(entry)
+msgid "format the generated SQL nicely in the script"
+msgstr ""
+
+#: toolset_guide.xml:345(literal)
+msgid "--delimiter=;"
+msgstr ""
+
+#: toolset_guide.xml:346(entry)
+msgid "set an end of line delimiter for the script"
+msgstr ""
+
+#: toolset_guide.xml:352(para)
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr ""
+
+#: toolset_guide.xml:362(title)
+msgid "Properties"
+msgstr ""
+
+#: toolset_guide.xml:364(para)
+msgid "Database properties may be specified"
+msgstr ""
+
+#: toolset_guide.xml:370(para)
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr ""
+
+#: toolset_guide.xml:373(para)
+msgid "in <literal>hibernate.properties</literal>"
+msgstr ""
+
+#: toolset_guide.xml:376(para)
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr ""
+
+#: toolset_guide.xml:380(para)
+msgid "The needed properties are:"
+msgstr ""
+
+#: toolset_guide.xml:385(title)
+msgid "SchemaExport Connection Properties"
+msgstr ""
+
+#: toolset_guide.xml:391(entry)
+msgid "Property Name"
+msgstr ""
+
+#: toolset_guide.xml:397(literal)
+msgid "hibernate.connection.driver_class"
+msgstr ""
+
+#: toolset_guide.xml:398(entry)
+msgid "jdbc driver class"
+msgstr ""
+
+#: toolset_guide.xml:401(literal)
+msgid "hibernate.connection.url"
+msgstr ""
+
+#: toolset_guide.xml:402(entry)
+msgid "jdbc url"
+msgstr ""
+
+#: toolset_guide.xml:405(literal)
+msgid "hibernate.connection.username"
+msgstr ""
+
+#: toolset_guide.xml:406(entry)
+msgid "database user"
+msgstr ""
+
+#: toolset_guide.xml:409(literal)
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: toolset_guide.xml:410(entry)
+msgid "user password"
+msgstr ""
+
+#: toolset_guide.xml:413(literal)
+msgid "hibernate.dialect"
+msgstr ""
+
+#: toolset_guide.xml:414(entry)
+msgid "dialect"
+msgstr ""
+
+#: toolset_guide.xml:423(title)
+msgid "Using Ant"
+msgstr ""
+
+#: toolset_guide.xml:425(para)
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr ""
+
+#: toolset_guide.xml:450(title)
+msgid "Incremental schema updates"
+msgstr ""
+
+#: toolset_guide.xml:452(para)
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr ""
+
+#: toolset_guide.xml:460(literal)
+msgid "org.hibernate.tool.hbm2ddl.SchemaUpdate"
+msgstr ""
+
+#: toolset_guide.xml:464(title)
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr ""
+
+#: toolset_guide.xml:481(entry)
+msgid "don't export the script to the database"
+msgstr ""
+
+#: toolset_guide.xml:493(literal) toolset_guide.xml:567(literal)
+msgid ".cfg.xml"
+msgstr ""
+
+#: toolset_guide.xml:493(entry) toolset_guide.xml:567(entry)
+msgid "specify a <placeholder-1/> file"
+msgstr ""
+
+#: toolset_guide.xml:499(para)
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr ""
+
+#: toolset_guide.xml:509(title)
+msgid "Using Ant for incremental schema updates"
+msgstr ""
+
+#: toolset_guide.xml:511(para)
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr ""
+
+#: toolset_guide.xml:532(title)
+msgid "Schema validation"
+msgstr ""
+
+#: toolset_guide.xml:534(para)
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr ""
+
+#: toolset_guide.xml:542(literal)
+msgid "org.hibernate.tool.hbm2ddl.SchemaValidator"
+msgstr ""
+
+#: toolset_guide.xml:546(title)
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr ""
+
+#: toolset_guide.xml:573(para)
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr ""
+
+#: toolset_guide.xml:583(title)
+msgid "Using Ant for schema validation"
+msgstr ""
+
+#: toolset_guide.xml:585(para)
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: toolset_guide.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/transactions.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/transactions.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/transactions.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,524 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:35-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: transactions.xml:5(title)
+msgid "Transactions And Concurrency"
+msgstr ""
+
+#: transactions.xml:7(para)
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr ""
+
+#: transactions.xml:14(para)
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr ""
+
+#: transactions.xml:22(para)
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr ""
+
+#: transactions.xml:29(para)
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr ""
+
+#: transactions.xml:36(title)
+msgid "Session and transaction scopes"
+msgstr ""
+
+#: transactions.xml:38(para)
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr ""
+
+#: transactions.xml:44(para)
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr ""
+
+#: transactions.xml:52(para)
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr ""
+
+#: transactions.xml:61(para)
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr ""
+
+#: transactions.xml:69(title)
+msgid "Unit of work"
+msgstr ""
+
+#: transactions.xml:71(para)
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr ""
+
+#: transactions.xml:87(para)
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr ""
+
+#: transactions.xml:99(para)
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr ""
+
+#: transactions.xml:112(para)
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: transactions.xml:120(para)
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr ""
+
+#: transactions.xml:135(title)
+msgid "Long conversations"
+msgstr ""
+
+#: transactions.xml:137(para)
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr ""
+
+#: transactions.xml:147(para)
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr ""
+
+#: transactions.xml:154(para)
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr ""
+
+#: transactions.xml:162(para)
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr ""
+
+#: transactions.xml:168(para)
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr ""
+
+#: transactions.xml:176(para)
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr ""
+
+#: transactions.xml:189(para)
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr ""
+
+#: transactions.xml:197(para)
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr ""
+
+#: transactions.xml:207(para)
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr ""
+
+#: transactions.xml:220(para)
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr ""
+
+#: transactions.xml:229(title)
+msgid "Considering object identity"
+msgstr ""
+
+#: transactions.xml:231(para)
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr ""
+
+#: transactions.xml:240(term)
+msgid "Database Identity"
+msgstr ""
+
+#: transactions.xml:243(literal)
+msgid "foo.getId().equals( bar.getId() )"
+msgstr ""
+
+#: transactions.xml:248(term)
+msgid "JVM Identity"
+msgstr ""
+
+#: transactions.xml:251(literal)
+msgid "foo==bar"
+msgstr ""
+
+#: transactions.xml:257(para)
+msgid "Then for objects attached to a <emphasis>particular</emphasis><literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr ""
+
+#: transactions.xml:266(para)
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr ""
+
+#: transactions.xml:275(para)
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr ""
+
+#: transactions.xml:296(title)
+msgid "Common issues"
+msgstr ""
+
+#: transactions.xml:298(para)
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr ""
+
+#: transactions.xml:307(para)
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr ""
+
+#: transactions.xml:318(para)
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr ""
+
+#: transactions.xml:330(para)
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr ""
+
+#: transactions.xml:348(title)
+msgid "Database transaction demarcation"
+msgstr ""
+
+#: transactions.xml:350(para)
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr ""
+
+#: transactions.xml:360(para)
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr ""
+
+#: transactions.xml:370(para)
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr ""
+
+#: transactions.xml:379(para)
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr ""
+
+#: transactions.xml:385(para)
+msgid "flush the session"
+msgstr ""
+
+#: transactions.xml:390(para)
+msgid "commit the transaction"
+msgstr ""
+
+#: transactions.xml:395(para)
+msgid "close the session"
+msgstr ""
+
+#: transactions.xml:400(para)
+msgid "handle exceptions"
+msgstr ""
+
+#: transactions.xml:406(para)
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr ""
+
+#: transactions.xml:413(title)
+msgid "Non-managed environment"
+msgstr ""
+
+#: transactions.xml:415(para)
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr ""
+
+#: transactions.xml:441(para)
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\">FlushMode</xref> for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr ""
+
+#: transactions.xml:450(para)
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr ""
+
+#: transactions.xml:469(para)
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr ""
+
+#: transactions.xml:479(para)
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr ""
+
+#: transactions.xml:488(title)
+msgid "Using JTA"
+msgstr ""
+
+#: transactions.xml:490(para)
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr ""
+
+#: transactions.xml:497(para)
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr ""
+
+#: transactions.xml:522(para)
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr ""
+
+#: transactions.xml:546(para)
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr ""
+
+#: transactions.xml:558(para)
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr ""
+
+#: transactions.xml:566(para)
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr ""
+
+#: transactions.xml:575(para)
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr ""
+
+#: transactions.xml:591(title)
+msgid "Exception handling"
+msgstr ""
+
+#: transactions.xml:593(para)
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr ""
+
+#: transactions.xml:604(para)
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr ""
+
+#: transactions.xml:616(para)
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr ""
+
+#: transactions.xml:632(para)
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr ""
+
+#: transactions.xml:638(para)
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr ""
+
+#: transactions.xml:644(para)
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr ""
+
+#: transactions.xml:650(para)
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr ""
+
+#: transactions.xml:656(para)
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr ""
+
+#: transactions.xml:666(title)
+msgid "Transaction timeout"
+msgstr ""
+
+#: transactions.xml:668(para)
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr ""
+
+#: transactions.xml:701(para)
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr ""
+
+#: transactions.xml:711(title)
+msgid "Optimistic concurrency control"
+msgstr ""
+
+#: transactions.xml:713(para)
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr ""
+
+#: transactions.xml:724(title)
+msgid "Application version checking"
+msgstr ""
+
+#: transactions.xml:726(para)
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr ""
+
+#: transactions.xml:747(para)
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr ""
+
+#: transactions.xml:753(para)
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr ""
+
+#: transactions.xml:762(para)
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr ""
+
+#: transactions.xml:773(title)
+msgid "Extended session and automatic versioning"
+msgstr ""
+
+#: transactions.xml:775(para)
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr ""
+
+#: transactions.xml:784(para)
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr ""
+
+#: transactions.xml:800(para)
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr ""
+
+#: transactions.xml:815(para)
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr ""
+
+#: transactions.xml:825(para)
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr ""
+
+#: transactions.xml:831(para)
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr ""
+
+#: transactions.xml:839(para)
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr ""
+
+#: transactions.xml:849(title)
+msgid "Detached objects and automatic versioning"
+msgstr ""
+
+#: transactions.xml:851(para)
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr ""
+
+#: transactions.xml:867(para)
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr ""
+
+#: transactions.xml:872(para)
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr ""
+
+#: transactions.xml:881(title)
+msgid "Customizing automatic versioning"
+msgstr ""
+
+#: transactions.xml:883(para)
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr ""
+
+#: transactions.xml:890(para)
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr ""
+
+#: transactions.xml:901(para)
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr ""
+
+#: transactions.xml:907(para)
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr ""
+
+#: transactions.xml:925(title)
+msgid "Pessimistic Locking"
+msgstr ""
+
+#: transactions.xml:927(para)
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr ""
+
+#: transactions.xml:934(para)
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr ""
+
+#: transactions.xml:939(para)
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr ""
+
+#: transactions.xml:946(para)
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr ""
+
+#: transactions.xml:952(para)
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr ""
+
+#: transactions.xml:958(para)
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr ""
+
+#: transactions.xml:964(para)
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr ""
+
+#: transactions.xml:971(para)
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr ""
+
+#: transactions.xml:980(para)
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr ""
+
+#: transactions.xml:986(para)
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr ""
+
+#: transactions.xml:991(para)
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr ""
+
+#: transactions.xml:996(para)
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr ""
+
+#: transactions.xml:1002(para)
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr ""
+
+#: transactions.xml:1011(para)
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr ""
+
+#: transactions.xml:1018(para)
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr ""
+
+#: transactions.xml:1027(title)
+msgid "Connection Release Modes"
+msgstr ""
+
+#: transactions.xml:1029(para)
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr ""
+
+#: transactions.xml:1043(para)
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr ""
+
+#: transactions.xml:1050(para)
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr ""
+
+#: transactions.xml:1056(para)
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr ""
+
+#: transactions.xml:1066(para)
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr ""
+
+#: transactions.xml:1073(para)
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr ""
+
+#: transactions.xml:1083(para)
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr ""
+
+#: transactions.xml:1089(para)
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr ""
+
+#: transactions.xml:1097(para)
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: transactions.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/tutorial.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/tutorial.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/tutorial.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,568 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:35-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: tutorial.xml:7(title)
+msgid "Introduction to Hibernate"
+msgstr ""
+
+#: tutorial.xml:10(title)
+msgid "Preface"
+msgstr ""
+
+#: tutorial.xml:12(para)
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr ""
+
+#: tutorial.xml:18(para)
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr ""
+
+#: tutorial.xml:24(para)
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr ""
+
+#: tutorial.xml:32(title)
+msgid "Part 1 - The first Hibernate Application"
+msgstr ""
+
+#: tutorial.xml:34(para)
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr ""
+
+#: tutorial.xml:39(para)
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr ""
+
+#: tutorial.xml:44(para)
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr ""
+
+#: tutorial.xml:65(para)
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr ""
+
+#: tutorial.xml:74(para)
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr ""
+
+#: tutorial.xml:79(title)
+msgid "The first class"
+msgstr ""
+
+#: tutorial.xml:81(para)
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr ""
+
+#: tutorial.xml:122(para)
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr ""
+
+#: tutorial.xml:130(para)
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr ""
+
+#: tutorial.xml:142(para)
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr ""
+
+#: tutorial.xml:149(para)
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr ""
+
+#: tutorial.xml:161(para)
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr ""
+
+#: tutorial.xml:168(title)
+msgid "The mapping file"
+msgstr ""
+
+#: tutorial.xml:170(para)
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr ""
+
+#: tutorial.xml:177(para)
+msgid "The basic structure of a mapping file looks like this:"
+msgstr ""
+
+#: tutorial.xml:190(para)
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr ""
+
+#: tutorial.xml:201(para)
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr ""
+
+#: tutorial.xml:206(para)
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr ""
+
+#: tutorial.xml:221(para)
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr ""
+
+#: tutorial.xml:239(para)
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr ""
+
+#: tutorial.xml:252(para)
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr ""
+
+#: tutorial.xml:271(para)
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr ""
+
+#: tutorial.xml:278(para)
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr ""
+
+#: tutorial.xml:287(para)
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr ""
+
+#: tutorial.xml:303(para)
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr ""
+
+#: tutorial.xml:319(para)
+msgid "We continue with the main configuration of Hibernate."
+msgstr ""
+
+#: tutorial.xml:326(title)
+msgid "Hibernate configuration"
+msgstr ""
+
+#: tutorial.xml:328(para)
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr ""
+
+#: tutorial.xml:336(para)
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr ""
+
+#: tutorial.xml:346(para)
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr ""
+
+#: tutorial.xml:356(para)
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr ""
+
+#: tutorial.xml:401(para)
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr ""
+
+#: tutorial.xml:409(para)
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr ""
+
+#: tutorial.xml:422(para)
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr ""
+
+#: tutorial.xml:431(title)
+msgid "Building with Ant"
+msgstr ""
+
+#: tutorial.xml:433(para)
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr ""
+
+#: tutorial.xml:442(para)
+msgid "A basic build file looks like this:"
+msgstr ""
+
+#: tutorial.xml:479(para)
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr ""
+
+#: tutorial.xml:501(title)
+msgid "Startup and helpers"
+msgstr ""
+
+#: tutorial.xml:503(para)
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr ""
+
+#: tutorial.xml:513(para)
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr ""
+
+#: tutorial.xml:545(para)
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr ""
+
+#: tutorial.xml:552(para)
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr ""
+
+#: tutorial.xml:561(para)
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr ""
+
+#: tutorial.xml:579(para)
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr ""
+
+#: tutorial.xml:589(para)
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr ""
+
+#: tutorial.xml:597(title)
+msgid "Loading and storing objects"
+msgstr ""
+
+#: tutorial.xml:599(para)
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr ""
+
+#: tutorial.xml:640(para)
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr ""
+
+#: tutorial.xml:647(para)
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr ""
+
+#: tutorial.xml:655(para)
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr ""
+
+#: tutorial.xml:666(para)
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr ""
+
+#: tutorial.xml:677(para)
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr ""
+
+#: tutorial.xml:688(para)
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr ""
+
+#: tutorial.xml:694(para)
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr ""
+
+#: tutorial.xml:705(para)
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr ""
+
+#: tutorial.xml:712(para)
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr ""
+
+#: tutorial.xml:719(para)
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr ""
+
+#: tutorial.xml:725(para)
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr ""
+
+#: tutorial.xml:741(para)
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr ""
+
+#: tutorial.xml:758(para)
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr ""
+
+#: tutorial.xml:765(para)
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr ""
+
+#: tutorial.xml:771(para)
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr ""
+
+#: tutorial.xml:777(para)
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr ""
+
+#: tutorial.xml:787(para)
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr ""
+
+#: tutorial.xml:793(para)
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr ""
+
+#: tutorial.xml:806(title)
+msgid "Part 2 - Mapping associations"
+msgstr ""
+
+#: tutorial.xml:808(para)
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr ""
+
+#: tutorial.xml:814(title)
+msgid "Mapping the Person class"
+msgstr ""
+
+#: tutorial.xml:816(para)
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr ""
+
+#: tutorial.xml:835(para)
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr ""
+
+#: tutorial.xml:853(para)
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr ""
+
+#: tutorial.xml:860(para)
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr ""
+
+#: tutorial.xml:870(title)
+msgid "A unidirectional Set-based association"
+msgstr ""
+
+#: tutorial.xml:872(para)
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr ""
+
+#: tutorial.xml:879(para)
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr ""
+
+#: tutorial.xml:897(para)
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr ""
+
+#: tutorial.xml:923(para)
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr ""
+
+#: tutorial.xml:935(para)
+msgid "The database schema for this mapping is therefore:"
+msgstr ""
+
+#: tutorial.xml:956(title)
+msgid "Working the association"
+msgstr ""
+
+#: tutorial.xml:958(para)
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr ""
+
+#: tutorial.xml:975(para)
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr ""
+
+#: tutorial.xml:990(para)
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr ""
+
+#: tutorial.xml:1025(para)
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr ""
+
+#: tutorial.xml:1032(para)
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr ""
+
+#: tutorial.xml:1047(para)
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr ""
+
+#: tutorial.xml:1060(para)
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr ""
+
+#: tutorial.xml:1068(title)
+msgid "Collection of values"
+msgstr ""
+
+#: tutorial.xml:1070(para)
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr ""
+
+#: tutorial.xml:1085(para)
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr ""
+
+#: tutorial.xml:1094(para)
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr ""
+
+#: tutorial.xml:1104(para)
+msgid "Have a look at the updated schema:"
+msgstr ""
+
+#: tutorial.xml:1122(para)
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr ""
+
+#: tutorial.xml:1128(para)
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr ""
+
+#: tutorial.xml:1146(para)
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr ""
+
+#: tutorial.xml:1156(title)
+msgid "Bi-directional associations"
+msgstr ""
+
+#: tutorial.xml:1158(para)
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr ""
+
+#: tutorial.xml:1166(para)
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr ""
+
+#: tutorial.xml:1180(para)
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr ""
+
+#: tutorial.xml:1189(para)
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr ""
+
+#: tutorial.xml:1197(para)
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr ""
+
+#: tutorial.xml:1206(title)
+msgid "Working bi-directional links"
+msgstr ""
+
+#: tutorial.xml:1208(para)
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr ""
+
+#: tutorial.xml:1218(para)
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr ""
+
+#: tutorial.xml:1241(para)
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr ""
+
+#: tutorial.xml:1248(para)
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr ""
+
+#: tutorial.xml:1263(para)
+msgid "Let's turn this into a small web application."
+msgstr ""
+
+#: tutorial.xml:1270(title)
+msgid "Part 3 - The EventManager web application"
+msgstr ""
+
+#: tutorial.xml:1272(para)
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr ""
+
+#: tutorial.xml:1280(title)
+msgid "Writing the basic servlet"
+msgstr ""
+
+#: tutorial.xml:1282(para)
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr ""
+
+#: tutorial.xml:1296(para)
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr ""
+
+#: tutorial.xml:1326(para)
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started-all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr ""
+
+#: tutorial.xml:1335(para)
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr ""
+
+#: tutorial.xml:1342(para)
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr ""
+
+#: tutorial.xml:1347(para)
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>-you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr ""
+
+#: tutorial.xml:1361(title)
+msgid "Processing and rendering"
+msgstr ""
+
+#: tutorial.xml:1363(para)
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr ""
+
+#: tutorial.xml:1394(para)
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application-keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr ""
+
+#: tutorial.xml:1412(para)
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr ""
+
+#: tutorial.xml:1440(para)
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr ""
+
+#: tutorial.xml:1455(para)
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr ""
+
+#: tutorial.xml:1469(title)
+msgid "Deploying and testing"
+msgstr ""
+
+#: tutorial.xml:1471(para)
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr ""
+
+#: tutorial.xml:1486(para)
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr ""
+
+#: tutorial.xml:1509(para)
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr ""
+
+#: tutorial.xml:1517(para)
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr ""
+
+#: tutorial.xml:1525(para)
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr ""
+
+#: tutorial.xml:1538(title)
+msgid "Summary"
+msgstr ""
+
+#: tutorial.xml:1540(para)
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: tutorial.xml:1545(para)
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: tutorial.xml:1553(para)
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: tutorial.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/content/xml.pot
===================================================================
--- core/trunk/documentation/manual/pot/content/xml.pot (rev 0)
+++ core/trunk/documentation/manual/pot/content/xml.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,120 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:35-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: xml.xml:5(title)
+msgid "XML Mapping"
+msgstr ""
+
+#: xml.xml:7(emphasis)
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr ""
+
+#: xml.xml:13(title)
+msgid "Working with XML data"
+msgstr ""
+
+#: xml.xml:15(para)
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr ""
+
+#: xml.xml:22(para)
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr ""
+
+#: xml.xml:32(para)
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr ""
+
+#: xml.xml:37(para)
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr ""
+
+#: xml.xml:44(title)
+msgid "Specifying XML and class mapping together"
+msgstr ""
+
+#: xml.xml:46(para)
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr ""
+
+#: xml.xml:73(title)
+msgid "Specifying only an XML mapping"
+msgstr ""
+
+#: xml.xml:75(para)
+msgid "Here is an example where there is no POJO class:"
+msgstr ""
+
+#: xml.xml:103(para)
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr ""
+
+#: xml.xml:114(title)
+msgid "XML mapping metadata"
+msgstr ""
+
+#: xml.xml:116(para)
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr ""
+
+#: xml.xml:125(para)
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr ""
+
+#: xml.xml:128(para)
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr ""
+
+#: xml.xml:131(para)
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr ""
+
+#: xml.xml:134(para)
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr ""
+
+#: xml.xml:141(para)
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr ""
+
+#: xml.xml:151(para)
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr ""
+
+#: xml.xml:191(para)
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr ""
+
+#: xml.xml:198(para)
+msgid "Would return datasets such as this:"
+msgstr ""
+
+#: xml.xml:213(para)
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr ""
+
+#: xml.xml:239(title)
+msgid "Manipulating XML data"
+msgstr ""
+
+#: xml.xml:241(para)
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr ""
+
+#: xml.xml:281(para)
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: xml.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/pot/legal_notice.pot
===================================================================
--- core/trunk/documentation/manual/pot/legal_notice.pot (rev 0)
+++ core/trunk/documentation/manual/pot/legal_notice.pot 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2007-10-19 10:26-0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ./legal_notice.xml:20(title)
+msgid "Legal Notice"
+msgstr ""
+
+#: ./legal_notice.xml:23(street)
+msgid "1801 Varsity Drive"
+msgstr ""
+
+#: ./legal_notice.xml:24(city)
+msgid "Raleigh"
+msgstr ""
+
+#: ./legal_notice.xml:24(state) ./legal_notice.xml:28(state)
+msgid "NC"
+msgstr ""
+
+#: ./legal_notice.xml:24(postcode)
+msgid "27606-2072"
+msgstr ""
+
+#: ./legal_notice.xml:24(country) ./legal_notice.xml:28(country)
+msgid "USA"
+msgstr ""
+
+#: ./legal_notice.xml:25(phone)
+msgid "Phone: +1 919 754 3700"
+msgstr ""
+
+#: ./legal_notice.xml:26(phone)
+msgid "Phone: 888 733 4281"
+msgstr ""
+
+#: ./legal_notice.xml:27(fax)
+msgid "Fax: +1 919 754 3701"
+msgstr ""
+
+#: ./legal_notice.xml:28(pob)
+msgid "PO Box 13588"
+msgstr ""
+
+#: ./legal_notice.xml:28(city)
+msgid "Research Triangle Park"
+msgstr ""
+
+#: ./legal_notice.xml:28(postcode)
+msgid "27709"
+msgstr ""
+
+#: ./legal_notice.xml:22(address)
+msgid "<placeholder-1/><placeholder-2/>, <placeholder-3/><placeholder-4/><placeholder-5/><placeholder-6/><placeholder-7/><placeholder-8/><placeholder-9/><placeholder-10/>, <placeholder-11/><placeholder-12/><placeholder-13/>"
+msgstr ""
+
+#: ./legal_notice.xml:31(para)
+msgid "Copyright <trademark class=\"copyright\"/> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr ""
+
+#: ./legal_notice.xml:34(para)
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr ""
+
+#: ./legal_notice.xml:37(para)
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr ""
+
+#: ./legal_notice.xml:40(para)
+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 ""
+
+#: ./legal_notice.xml:43(para)
+msgid "All other trademarks referenced herein are the property of their respective owners."
+msgstr ""
+
+#: ./legal_notice.xml:46(para)
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr ""
+
+#: ./legal_notice.xml:49(para)
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: ./legal_notice.xml:0(None)
+msgid "translator-credits"
+msgstr ""
+
Added: core/trunk/documentation/manual/translations/es-ES/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - Persistencia Relacional para Java Idiomático"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "Documentación de Referencia de Hibernate"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr "Arquitectura"
+
+#: index.docbook:24
+msgid "Overview"
+msgstr "Visión General"
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr "Una visión a (muy) alto nivel de la arquitectura de Hibernate:"
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr "Este diagrama muestra a Hibernate usando la base de datos y los datos de configuración para proveer servicios de persistencia (y objetos persistentes) a la aplicación."
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 "Nos gustaría mostrar una vista más detallada de la arquitectura de tiempo de ejecución. Desafortunadamente, Hibernate es flexible y soporta diferentes enfoques. Mostraremos los dos extremos. En la arquitectura \"sencilla\", es la aplicación la que provee su propias conexiones JDBC y gestiona sus propias transacciones. Este enfoque usa un mínimo subconjunto de la API de Hibernate:"
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr "La arquitectura \"full cream\" abstrae a la aplicación de las APIs de JDBC/JTA y deja que Hibernate se encargue de los detalles."
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr "He aquí algunas definiciones de los objetos en los diagramas:"
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr "Caché threadsafe (inmutable) de mapeos compilados para una sola base de datos. Es una fábrica de <literal>Session</literal> y un cliente de <literal>ConnectionProvider</literal>. Opcionalmente, puede mantener una caché (de segundo nivel) de datos reusables entre transacciones, a un nivel de proceso o de cluster."
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr "Session (<literal>org.hibernate.Session</literal>)"
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr "Objeto mono-hebra, de corta vida que representa una conversación entre la aplicación y el almacenamiento persistente. Envuelve una conexión JDBC. Es una fábrica de <literal>Transaction</literal>. Mantiene una caché requerida (de primer nivel) de objetos persistentes, usada mientras se navega el grafo de objetos o se recuperen objetos por identificador."
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr "Objetos y colecciones persistentes"
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr "Objetos de corta vida, mono-hebra conteniendo estado persistente y funciónalidad de negocio. Estos pueden ser JavaBeans/POJOs (Plain Old Java Objects, o sea, cualquier objeto Java), la única cosa especial en ellos es que estan asociados actualmente con una (y sólo una) <literal>Session</literal>. Tan pronto como la <literal>Session</literal> sea cerrada, serán separados y estarán libres para ser usados en cualquier capa de aplicación. (por ejemplo, directamente como objetos de transferencia de datos hacia y desde la capa de presentación)."
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr "Objetos y colecciones transitorios y separados"
+
+#: index.docbook:119
+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 "Instancias de clases persistentes que no estan acutualmente asociadas con una <literal>Session</literal>. Pueden haber sido instanciadas por la aplicación y (aún) no haber sido hechas persistentes, o pueden haber sido instanciadas por una <literal>Session</literal> cerrada."
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr "Transaction (<literal>org.hibernate.Transaction</literal>)"
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 "(Opcional) Un objeto de corta vida, mono-hebra, usado por la aplicación para especificar unidades atómicas de trabajo. Abstrae a la aplicación de las subyacentes transacciones JDBC, JTA o CORBA. En algunos casos, una <literal>Session</literal> puede extenderse sobre varias <literal>Transaction</literal>s. Sin embargo, la demarcación de la transacción, ya sea usando la API subyacente o <literal>Transaction</literal>, nunca es opcional!"
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr "(Opcional) Una fábrica (y pool) de conexiones JDBC. Abstrae a la aplicación del <literal>Datasource</literal> o <literal>DriverManager</literal> subyacente. No se expone a la aplicación, pero puede ser extendido/implementado por el desarrollador."
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr "(Opcional) Una fábrica de instancias de <literal>Transaction</literal>. No se expone a la aplicación, pero puede ser extendido/implementado por el desarrollador."
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr "Interfaces de Extensión"
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "Hibernate ofrece muchas interfaces de extensión opcional que puedes implementar para modificar a medida el comportamiento de tu capa de persistencia. Para más detalles, mira la documentación de la API."
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr "Dada una arquitectura \"sencilla\", la aplicación pasa por alto las APIs de <literal>Transaction</literal>/<literal>TransactionFactory</literal> y/o <literal>ConnectionProvider</literal>, para hablar directamente a JTA o JDBC."
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr "Estados de instancia"
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr "Una instancia de una clase persistente puede estar en uno de tres estados diferentes, definidos respecto de su <emphasis>contexto de persistencia</emphasis>. El objeto <literal>Session</literal> de Hibernate es el contexto de persistencia:"
+
+#: index.docbook:188
+msgid "transient"
+msgstr "transitorio"
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr "La instancia no está y nunca estuvo asociada con un contexto de persistencia. No tiene identidad persistente (valor de clave primaria)."
+
+#: index.docbook:198
+msgid "persistent"
+msgstr "persistente"
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr "La instancia está actualmente asociada con un contexto de persistencia. Tiene una identidad persistente (valor de clave primaria) y, quizás, una fila correspondiente en la base de datos. Para un contexto de persistencia en particular, Hibernate <emphasis>garantiza</emphasis> que la identidad persistente es equivalente a la identidad Java (localización en memoria del objeto)."
+
+#: index.docbook:212
+msgid "detached"
+msgstr "separado"
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr "La instancia estuvo una vez asociada con un contexto de persistencia, pero ese contexto fue cerrado, o la instancia fue serializada a otro proceso. Tiene una identidad persistente y, quizás, una fila correspondiente en la base de datos. Para las instancias separadas, Hibernate no establece ninguna garantía sobre la relación entre identidad persistente e identidad Java."
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr "Integración JMX"
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX es el estándar J2EE para la gestión de componentes Java. Hibernate puede ser gestionado por medio de un servicio estándar JMX. Proveemos una implementación de MBean en la distribución, <literal>org.hibernate.jmx.HibernateService</literal>."
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr "Para ejemplo de cómo desplegar Hibernate como un servicio JMX en un Servidor de Aplicaciones JBoss, por favor, mira la Guía del Usuario de JBoss. En JBoss AS, tienes además estos beneficios si despliegas usando JMX:"
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>Gestión de Sesión:</emphasis> El ciclo de vida de la <literal>Session</literal> de Hibernate puede estar automáticamente ligado al ámbito de una transacción JTA. Esto significa que ya no tienes que abrir ni cerrar la <literal>Session</literal> manualmente, esto pasa a ser trabajo de un interceptor EJB de JBoss. Además tampoco tienes que preocuparte más de la demarcación de la transacción (a menos que que quieras escribir una capa de persitencia portable, por supuesto, usa la API de <literal>Transaction</literal> de Hibernate para esto). Para acceder a una <literal>Session</literal> llama al <literal>HibernateContext</literal>."
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>Despliegue de HAR:</emphasis> Usualmente despliegas el servicio JMX de Hibernate usando un descriptor de despliegue de servicio de JBoss (en un fichero EAR y/o SAR), que soporta todas las opciones de configuración usuales de una <literal>SessionFactory</literal> de Hibernate. Sin embargo, todavía tienes que nombrar todos tus ficheros de mapeo en el descriptor de despliegue. Si decides usar el depliegue de HAR opcional, JBoss detectará automáticamente todos los ficheros de mapeo en tu fichero HAR."
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr "Para más información sobre estas opciones, consulta la Guía de Usuario del JBoss AS."
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr "Otra funcionalidad disponible como un servicio JMX son las estadísticas en tiempo de ejecución de Hibernate. Mira <xref linkend=\"configuration-optional-statistics\"/>."
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr "Soporte JCA:"
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr "Hiberate puede además ser configurado como un conector JCA. Por favor mira el sitio web para más detalles. Por favor ten en cuenta que el soporte de JCA de Hibernate está aún considerado experimental."
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr ""
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 ""
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr ""
+
+#: index.docbook:307
+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 ""
+
+#: index.docbook:314
+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 ""
+
+#: index.docbook:324
+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 ""
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr ""
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr ""
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,881 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr "Mapeos de Asociación"
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr "Introducción"
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr "Los mapeos de asociación son frecuentemente las cosas mas difíciles de hacer correctamente. En esta sección iremos a través de los casos canónicos uno a uno, comenzando con los mapeos unidireccionales, y considerando luego los casos bidireccionales. Usaremos <literal>Person</literal> y <literal>Address</literal> en todos los ejemplos."
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr "Clasificaremos las asociaciones por cuanto mapeen o no a una tabla de unión interviniente, y por su multiplicidad."
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr "Las claves foráneas que aceptan valores nulos (en adelante, nullables) no son consideradas una buena práctica en el modelado tradicional de datos, así que todos nuestros ejemplos usan claves foráneas no nullables. Esto no es un requerimiento de Hibernate, y todos los mapeos funcionarán si quitas las restricciones de nulabilidad."
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr "Asociaciones Unidireccionales"
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr "muchos a uno"
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr "Una <emphasis>asociación unidireccional muchos-a-uno</emphasis> es el tipo más común de asociaciones unidireccionales."
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr "uno a uno"
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr "Una <emphasis>asociación unidireccional uno-a-uno en una clave primaria</emphasis> es casi idéntica. La única diferencia es la restricción de unicidad de la columna."
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr "Usualmente, una <emphasis>asociación unidireccional uno-a-uno en una clave primaria</emphasis> usa un generador de id especial. (Observa que hemos invertido el sentido de la asociación en este ejemplo)."
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr "uno a muchos"
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr "Una <emphasis>asociación unidireccional uno-a-muchos en una clave foránea</emphasis> es un caso muy inusual, y realmente no está recomendada."
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr "Creemos que es mejor usar una tabla de unión para este tipo de asociación."
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr "Asociaciones unidireccionales con tablas de unión"
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr "Una <emphasis>asociación unidireccional uno-a-muchos en una tabla de unión</emphasis> es más preferible. Observa que especificando <literal>unique=\"true\"</literal>, hemos cambiado la multiplicidad de muchos-a-muchos a uno-a-muchos."
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr "Una <emphasis>asociación unidireccional muchos-a-uno en una tabla de unión</emphasis> es bastante común cuando la asociación es opcional."
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "Una <emphasis>asociación unidireccional uno-a-uno en una tabla de unión</emphasis> es inusual en extremo, pero posible."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr "muchos a muchos"
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr "Finalmente, tenemos una <emphasis>asociación unidireccional muchos-a-muchos</emphasis>"
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr "Asociaciones Bidireccionales"
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr "uno a muchos / muchos a uno"
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr "Una <emphasis>asociación bidireccional muchos-a-uno</emphasis> es el tipo más común de asociación. (Esta es la relación estándar padre/hijo.)"
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr "uno a uno"
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr "Una <emphasis>asociación bidireccional uno-a-uno en una clave foránea</emphasis> es bastante común."
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr "Una <emphasis>asociación bidireccional uno-a-uno en una clave primaria</emphasis> usa el generador de id especial."
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr "Asociaciones bidireccionales con tablas de unión"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr "uno a muchos / muchos a uno"
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr "uno a uno"
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr "Una <emphasis>asociación bidireccional uno-a-uno en una tabla de unión</emphasis> es inusual en extremo, pero posible."
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "muchos a muchos"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr "Finalmente, tenemos una <emphasis>asociación bidireccional muchos-a-muchos</emphasis>."
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr ""
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr ""
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr ""
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr ""
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,3067 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr "Mapeo O/R Básico"
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr "Declaración de mapeo"
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr "Los mapeos objeto/relacional se definen usualmente en un documento XML. El documento de mapeo está diseñado para ser leíble y editable a mano. El lenguaje de mapeo es Java-céntrico, o sea que los mapeos se construyen alrededor de declaraciones de clases persistentes, no declaraciones de tablas."
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr "Observa que, incluso aunque muchos usuarios de Hibernate eligen escribir el XML a mano, existe una cantidad de herramientas para generar el documento de mapeo, incluyendo XDoclet, Middlegen y AndroMDA."
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr "Comencemos por un mapeo de ejemplo:"
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" \n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\" \n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\" \n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr "Discutiremos ahora el contenido del documento de mapeo. Describiremos sólo los elementos y atributos que son usados por Hibernate en tiempo de ejecución. El documento de mapeo contiene además algunos atributos y elementos extra opcionales que afectan los esquemas de base de datos exportados por la herramienta de exportación de esquemas. (Por ejemplo, el atributo <literal>not-null</literal>.)"
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr "Doctype"
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr "Todos los mapeos XML deben declarar el doctype mostrado. El DTD actual puede ser encontrado en el URL mencionado arriba, en el directorio <literal>hibernate-x.x.x/src/org/hibernate</literal>, o en <literal>hibernate3.jar</literal>. Hibernate siempre buscará el DTD primero en el classpath. Si experimentas búsquedas del DTD usando una conexión de Internet, chequea tu declaración de DTD contra la contenida en el classpath."
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr "hibernate-mapping"
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr "Este elemento tiene muchos atributos opcionales. Los atributos <literal>schema</literal> y <literal>catalog</literal> especifican que las tablas a las que se refiere en el mapeo pertenecen al esquema y/o catálogo mencionado(s). De especificarse, los nombres de tablas serán cualificados por el nombre de esquema y catálogo dados. De omitirse, los nombres de tablas no serán cualificados. El atributo <literal>default-cascade</literal> especifica qué estilo de cascada debe asumirse para las propiedades y colecciones que no especifican un atributo <literal>cascade</literal>. El atributo <literal>auto-import</literal> nos permite usar nombres de clase sin cualificar en el lenguaje de consulta, por defecto."
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "<literal>schema</literal> (opcional): El nombre de un esquema de la base de datos."
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr "<literal>catalog</literal> (opcional): El nombre de un catálogo de la base de datos."
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr "<literal>default-cascade</literal> (opcional - por defecto a <literal>none</literal>): Un estilo de cascada por defecto."
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr "<literal>default-access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder a todas las propiedades. Puede ser una implementación personalizada de <literal>PropertyAccessor</literal>."
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr "<literal>default-lazy</literal> (opcional - por defecto a <literal>true</literal>): El valor por defecto para los atributos <literal>lazy</literal> de mapeos de clase y colleción no especificados."
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr "<literal>auto-import</literal> (opcional - por defecto a <literal>true</literal>): Especifica si podemos usar nombres de clases no cualificados (de clases en este mapeo) en el lenguaje de consulta."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr "<literal>package</literal> (opcional): Especifica un prefijo de paquete a asumir para los nombres no cualificados de clase en el documento de mapeo."
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr "Si tienes dos clases persistentes con el mismo nombre (sin cualificar), debes establecer <literal>auto-import=\"false\"</literal>. Hibernate lanzará una excepción si intentas asignar dos clases al mismo nombre \"importado\"."
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr "Observa que el elemento <literal>hibernate-mapping</literal> te permite anidar muchos mapeos <literal><class></literal> persistentes, como se muestra arriba. Sin embargo, es una buena práctica (y se espera de algunas herramientas) mapear sólo a una sola clase persistente (o a una sola jerarquía de clases) en un fichero de mapeo y nombrarlo después de la superclase persistente; por ejemplo, <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, o, si se usa herencia, <literal>Animal.hbm.xml</literal>."
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr "<title>class</title>"
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "Puedes declarar una clase persistente usando el elemento <literal>class</literal>:"
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr "<literal>name</literal> (opcional): El nombre completamente cualificado de la clase Java persistente (o interface). Si este atributo es omitido, se asume que el mapeo es para una entidad non-POJO."
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr "<literal>table</literal> (opcional - por defecto al nombre no cualificado de la clase): El nombre de su tabla en base de datos."
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr "<literal>discriminator-value</literal> (opcional - por defecto al nombre de la clase): Un valor que distingue subclases individuales, usado para el comportamiento polimórfico. Los valores aceptables incluyen <literal>null</literal> y <literal>not null</literal>."
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "<literal>mutable</literal> (opcional, por defecto a <literal>true</literal>): Especifica que las instancias de la clase (no) son mutables."
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr "<literal>schema</literal> (opcional): Sobreescribe el nombre de esquema especificado por el elemento raíz <literal><hibernate-mapping></literal>."
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr "<literal>catalog</literal> (opcional): Sobreescribe el nombre de catálogo especificado por el elemento raíz <literal><hibernate-mapping></literal>."
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr "<literal>proxy</literal> (opcional): Especifica una interface a usar para proxies de inicialización perezosa. Puedes especificar el nombre mismo de la clase."
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>dynamic-update</literal> (opcional, por defecto a <literal>false</literal>): Especifica que el SQL <literal>UPDATE</literal> debe ser generado en tiempo de ejecución y contener solamente aquellas columnas cuyo valor haya cambiado."
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr "<literal>dynamic-insert</literal> (opcional, por defecto a <literal>false</literal>): Especifica que el SQL <literal>INSERT</literal> debe ser generado en tiempo de ejecución y contener solamente aquellas columnas cuyo valores no son nulos."
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>select-before-update</literal> (opcional, por defecto a <literal>false</literal>): Especifica que Hibernate <emphasis>nunca</emphasis> debe realizar un SQL <literal>UPDATE</literal> a menos que se tenga certeza que un objeto haya sido modificado realmente. En ciertos casos, (realmente, sólo cuando un objeto transitorio ha sido asociado con una sesión nueva usando <literal>update()</literal>), esto significa que Hibernate realizará una SQL <literal>SELECT</literal> extra para determinar si un <literal>UPDATE</literal> es realmente requerido."
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr "<literal>polymorphism</literal> (opcional, por defecto a <literal>implicit</literal>): Determina si se usa polimorfismo de consulta implícito o explícito."
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>where</literal> (opcional) especifica una condición SQL <literal>WHERE</literal> arbitraria paraa ser usada al recuperar objetos de esta clase."
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>persister</literal> (opcional): Especifica un <literal>ClassPersister</literal> personalizado."
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr "<literal>batch-size</literal> (opcional, por defecto a <literal>1</literal>) especifica un \"tamaño de lote\" para traer instancias de esta clase por identificador."
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr "<literal>optimistic-lock</literal> (opcional, por defecto a <literal>version</literal>): Determina la estrategia optimista de bloqueo."
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>lazy</literal> (opcional): La recuperación perezosa puede ser deshabilitada por completo estableciendo <literal>lazy=\"false\"</literal>."
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>entity-name</literal> (opcional): Hibernate3 permite que una clase sea mapeada varias veces (potencialmente a tablas diferentes), y permite que los mapeos de entidad sean representados por Maps o XML al nivel de Java. En estos casos, debes proveer un nombre explícito arbitrario para la entidad. Para más información, mira <xref linkend=\"persistent-classes-dynamicmodels\"/> y <xref linkend=\"xml\"/>."
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr "<literal>check</literal> (opcional): Una expresión SQL usada para generar una restricción <emphasis>check</emphasis> multi-fila para la generación automática de esquema."
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr "<literal>rowid</literal> (opcional): Hibernate puede usar los llamados ROWIDs en las bases de datos que los soporten. Por ejemplo, en Oracle, Hibernate puede usar la columna extra <literal>rowid</literal> para actualizaciones rápidas si estableces esta opción a <literal>rowid</literal>. Un ROWID es un detalle de implementación y representa la posición física de la tupla almacenada."
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>subselect</literal> (opcional): Mapea una entidad inmutable y de sólo lectura a una subselect de base de datos. Es útil si quieres tener una vista en vez de una tabla base, pero no tienes vistas. Mira debajo para más información."
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>abstract</literal> (opcional): Usado para marcar superclases abstractas en jerarquías <literal><union-subclass></literal>."
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr "Es perfectamente aceptable que la clase persistente mencionada sea una interface. Entonces declararías clases que implementan esa interface usando el elemento <literal><subclass></literal>. Puedes persistir cualquier clase interna <emphasis>estática</emphasis>. Debes especificar el nombre de la clase usando la forma estándar. Por ejemplo, <literal>eg.Foo$Bar</literal>."
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "Las clases inmutables, <literal>mutable=\"false\"</literal>, no pueden ser actualizadas o borradas por la aplicación. Esto permite a Hibernate hacer ciertas optimizaciones menores de rendimiento."
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr "El atributo opcional <literal>proxy</literal> habilita la inicialización postergada de instancias persistentes de la clase. Hibernate inicialmente retornará proxies CGLIB que implementan la interface mencionada. El objeto persistente real será cargado cuando se invoque un método del proxy. Mira \"Proxies para Inicialización Postergada\" debajo."
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "Por polimorfismo <emphasis>implícito</emphasis> se entiende que las instancias de la clase serán devueltas por una consulta que mencione cualquier superclase, o interface implementada, o la clase misma; y que las instancias de cualquier subclase de la clase serán devueltas por una clase que mencione a la clase en sí. Por polimorfismo <emphasis>explícito</emphasis> se entiende que instancias de la clase serán devueltas sólo por consultas que mencionen explícitamente la clase; y que las consultas que mencionen la clase devolverán sólo instancias de subclases mapeadas dentro de esta declaración <literal><class></literal> como una <literal><subclass></literal> o <literal><joined-subclass></literal>. Para la mayoría de los propósitos el defecto, <literal>polymorphism=\"implicit\"</literal>, resulta apropiado. El polimorfismo explícito es útil cuando !
dos clases diferentes están mapeadas a la misma tabla (esto permite tener una clase \"liviana\" que contenga un subconjunto de columnas de la tabla)."
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "El atributo <literal>persister</literal> te permite personalizar la estrategia de persistencia para la clase. Puedes, por ejemplo, especificar tu propia subclase de <literal>org.hibernate.persister.EntityPersister</literal> o incluso puedes proveer una implementación completamente nueva de la interface <literal>org.hibernate.persister.ClassPersister</literal> que implemente la persistencia por medio, por ejemplo, de llamadas a procedimientos almacenados, serialización a ficheros planos o LDAP. Para un ejemplo simple (de persistencia a una <literal>Hashtable</literal>) mira <literal>org.hibernate.test.CustomPersister</literal>."
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr "Observa que los valores de <literal>dynamic-update</literal> y <literal>dynamic-insert</literal> no son heredados por las subclases y por lo tanto deben especificarse en los elementos <literal><subclass></literal> o <literal><joined-subclass></literal>. Estos ajustes pueden incrementar el rendimiento en algunos casos, pero podrían mermarlo en otros. Ten juicio en su uso."
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr "Generalmente el uso de <literal>select-before-update</literal> disminuirá el rendimiento. Es muy útil prevenir que se llame innecesariamente a un disparador de actualización de base de datos al volver a unir un grafo de instancias separadas a una <literal>Session</literal>."
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr "Si habilitas <literal>dynamic-update</literal>, tendrás opción de estrategias de bloqueo optimistas:"
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "<literal>version</literal> chequea las columnas de versión/timestamp"
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "<literal>all</literal> chequea todas las columnas"
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr "<literal>dirty</literal> chequea las columnas modificadas, permitiendo algunas actualizaciones concurrentes"
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr "<literal>none</literal> no usa bloqueo optimista"
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr "Recomendamos <emphasis>muy</emphasis> fuertemente que uses columnas de versión/timestamp para bloqueo optimista con Hibernate. Esta es la estrategia óptima con respecto al rendimiento y es la única estrategia que maneja correctamente las modificaciones hechas a las instancias separadas. (por ejemplo, cuando se usa <literal>Session.merge()</literal>)."
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "Para un mapeo de Hibernate, no hay diferencia entre una vista y una tabla base. Como se supone esto es transparente a nivel de base de datos (observa que algunos DBMS no soportan correctamente las vistas, especialmente con las actualizaciones). A veces quieres usar una vista, pero no puedes crear una en la base de datos (por ejemplo, con un esquema heredado). En este caso, puedes mapear una entidad inmutable de sólo lectura a una expresión de subconsulta SQL dada."
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr "Declara las tablas con las que sincronizar esta entidad, asegurando que el auto-flush ocurre correctamente, y que las consultas contra la entidad derivada no devuelven datos desactualizados. El <literal><subselect></literal> está disponible tanto como un atributo o como un elemento anidado de mapeo."
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr "<title>id</title>"
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr "Las clases mapeadas <emphasis>deben</emphasis> declarar la columna de clave primaria de la tabla de la base de datos. En la mayoría de los casos tendrá también una propiedad estilo Javabeans que tenga el identificador único de una instancia. El elemento <literal><id></literal> define el mapeo de esa propiedad a la columna de clave primaria."
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\">\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr "<literal>name</literal> (opcional): El nombre de la propiedad del indentificador."
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "<literal>type</literal> (opcional): Un nombre que indica el tipo Hibernate."
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr "<literal>column</literal> (opcional - por defecto al nombre de la propiedad): El nombre de la columna de clave primaria."
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr "<literal>unsaved-value</literal> (opcional - por defecto al valor \"sensible\"): Una valor de la propiedad identificadora que indica que una instancia está recién instanciada (sin salvar), distinguiéndola de instancias separadas que fueran salvadas o cargadas en una sesión previa."
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr "Si se omite el atributo <literal>name</literal>, se asume que la clase no tiene propiedad identificadora."
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr "El atributo <literal>unsaved-value</literal> es importante! Si la propiedad identificadora de tu clase no tiene por defecto el valor por defecto normal de Java (null o cero), entonces debes especificar el valor por defecto real."
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr "Hay una declaración <literal><composite-id></literal> alternativa para permitir acceso a datos heredados con claves compuestas. Desalentamos fuertemente su uso para cualquier otra cosa."
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr "Generator"
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr "El elemento hijo opcional <literal><generator></literal> nombra una clase Java usada en generar identificadores únicos para instancias de la clase persistente. De requerirse algún parámetro para configurar o inicializar la instancia del generador, se pasa usando el elemento <literal><param></literal>."
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr "Todos los generadores implementan la interface <literal>org.hibernate.id.IdentifierGenerator</literal>. Esta es una interface muy simple; algunas aplicaciones pueden escoger proveer sus propias implementaciones especializadas. Sin embargo, Hibernate provee un rango de implementaciones prefabricadas. Hay nombres alias de atajo para los generadores prefabricados:"
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr "increment"
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr "genera indentificadores de tipo <literal>long</literal>, <literal>short</literal> o <literal>int</literal> que sólo son únicos cuando ningún otro proceso está insertando datos en la misma tabla. <emphasis>No usar en un cluster.</emphasis>"
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr "identity"
+
+#: index.docbook:532
+msgid "Generator"
+msgstr "soporta columnas de identidad en DB2, MySQL, MS SQL Server, Sybase y HypersonicSQL. El identificador devuelto es de tipo <literal>long</literal>, <literal>short</literal> o <literal>int</literal>."
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr "sequence"
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "usa una secuencia en DB2, PostgreSQL, Oracle, SAP DB, McKoi o un generador en Interbase. El identificador devuelto es de tipo <literal>long</literal>, <literal>short</literal> o <literal>int</literal>."
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr "hilo"
+
+#: index.docbook:551
+msgid "increment"
+msgstr "usa un algoritmo alto/bajo para generar eficientemente identificadores de tipo <literal>long</literal>, <literal>short</literal> o <literal>int</literal>, dada una tabla y columna como fuente de valores altos (por defecto <literal>hibernate_unique_key</literal> y <literal>next_hi</literal> respectivamente). El algoritmo alto/bajo genera identificadores que son únicos sólo para una base de datos particular."
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "seqhilo"
+
+#: index.docbook:562
+msgid "identity"
+msgstr "usa un algoritmo alto/bajo para generar eficientemente identificadores de tipo <literal>long</literal>, <literal>short</literal> o <literal>int</literal>, dada una secuencia de base de datos."
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "uuid"
+
+#: index.docbook:572
+msgid "sequence"
+msgstr "usa un algoritmo UUID de 128 bits para generar identificadore de tipo cadena, únicos en una ref (se usa la direccón IP). El UUID se codifica como una cadena hexadecimal de 32 dígitos de largo."
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "guid"
+
+#: index.docbook:582
+msgid "hilo"
+msgstr "usa una cadena GUID generada por base de datos en MS SQL Server y MySQL."
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "native"
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr "selecciona <literal>identity</literal>, <literal>sequence</literal> o <literal>hilo</literal> dependiendo de las capacidades de la base de datos subyacente."
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "assigned"
+
+#: index.docbook:604
+msgid "uuid"
+msgstr "deja a la aplicación asignar un identificador al objeto antes de que se llame a <literal>save()</literal>. Esta es la estrategia por defecto si no se especifica un elemento <literal><generator></literal>."
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr "select"
+
+#: index.docbook:614
+msgid "guid"
+msgstr "recupera una clave primaria asignada por un disparador de base de datos seleccionando la fila por alguna clave única y recuperando el valor de la clave primaria."
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr "foreign"
+
+#: index.docbook:622
+msgid "native"
+msgstr "usa el identificador de otro objeto asociado. Generalmente usado en conjuncón a una asociacón de clave primaria <literal><uno-a-uno></literal>"
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "Algoritmo alto/bajo"
+
+#: index.docbook:632
+msgid "assigned"
+msgstr "Los generadores <literal>hilo</literal> y <literal>seqhilo</literal> proveen dos implementaciones alternativas del algoritmo alto/bajo, un enfoque favorito en generación de identificadores. La primera implementación requiere de una tabla \"especial\" de base de datos para tener el siguiente valor \"alto\" disponible. La segunda usa una secuencia del estilo de Oracle (donde se soporte)."
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:642
+msgid "select"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr "Desafortunadamente, no puedes usar <literal>hilo</literal> cuando le proveas tu propia <literal>Connection</literal> a Hibernate. Cuando Hibernate está usando un datasource del servidor de aplicaciones para obtener conexiones alistadas con JTA, debes configurar correctamente el <literal>hibernate.transaction.manager_lookup_class</literal>."
+
+#: index.docbook:651
+msgid "foreign"
+msgstr "Algoritmo UUID"
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr "El UUID contiene: la dirección IP, el instante de arranque de la JVM (con una precisión de un cuarto de segundo), el tiempo de sistema y un valor de contador (único en la JVM). No es posible obtener una dirección MAC o una dirección de memoria desde código Java, así que esto es lo mejor que podemos hacer sin usar JNI."
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr "Columnas de identidad y secuencias"
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "Para las bases de datos que soportan columnas de identidad (DB2, MySQL, Sybase, MS SQL), puedes usar generación de claves <literal>identity</literal>. Para las bases de datos que soportan secuencias (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) puedes usar la generación de claves del estilo <literal>sequence</literal>. Ambas estrategias requieren dos consultas SQL para insertar un nuevo objeto."
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "Para desarrollos multiplataforma, la estrategia <literal>native</literal> eiligirá de entre las estrategias <literal>identity</literal>, <literal>sequence</literal> y <literal>hilo</literal>, dependiendo de las capacidades de la base de datos subyacentes."
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "Identificadores asignados"
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "Si quieres que la aplicación asigne los identificadores (en contraposición a que los genere Hibernate), puedes usar el generador <literal>assigned</literal>. Este generador especial usará el valor identificador ya asignado a la propiedad identificadora del objeto. Este generador se usa cuandola clave primaria es una clave natural en vez de una clave sustituta. Este es el comportamiento por defecto si no especificas un elemento <literal><generator></literal>."
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr "Elegir el generador <literal>assigned</literal> hace que Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forzando a Hibernate a ir a la base de datos para determinar si una instancia es transitoria o separada, a menos que haya una propiedad de versión o timestamp, o que tu definas <literal>Interceptor.isUnsaved()</literal>."
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr "Claves primarias asignadas por disparadores"
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr "Para esquemas heredados solamente (Hibernate no genera DDL con disparadores)."
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "En el ejemplo de arriba, hay una propiedad ánica llamada <literal>socialSecurityNumber</literal> definida por la clase, como una clave natural, y una clave sustituta llamada <literal>person_id</literal> cuyo valor es generado por un disparador."
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr "composite-id"
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " unsaved-value=\"undefined|any|none\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " node=\"element-name|.\">\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr "Para una tabla con clave compuesta, puedes mapear múltiples propiedades de la clase como propiedades identificadoras. El elemento <literal><composite-id></literal> acepta los mapeos de propiedad <literal><key-property></literal> y los mapeos <literal><key-many-to-one></literal> como elementos hijo."
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr "Tu clase persistente <emphasis>debe</emphasis> sobreescribir <literal>equals()</literal> y <literal>hashCode()</literal> para implementar igualdad de identificador compuesto. Debe también implementar <literal>Serializable</literal>."
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr "Desafortunadamente, este enfoque de identificadores compuestos significa que un objeto persistente es su propio identificador. No existe otra \"asa\" conveniente más que el objeto mismo. Debes instanciar una instancia de la clase misma y poblar sus propiedades identificadoras antes que puedas <literal>load()</literal> el estado persistente asociado a una clave compuesta. Describiremos un enfoque mucho más conveniente donde el identificador compuesto está implementado como una clase separada en <xref linkend=\"components-compositeid\"/>. Los atributos descriptos debajo solamente se aplican a este enfoque alternativo:"
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr "<literal>name</literal> (opcional): Una propiedad de tipo componente que tiene el identificador compuesto (ver siguiente sección)."
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "<literal>class</literal> (opcional - por defecto al tipo de la propiedad determinado por reflección): La clase del componente usado como identificador compuesto (ver siguiente sección)."
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr "<literal>unsaved-value</literal> (opcional - por defecto a <literal>undefined</literal>): Indica que las instancias transitorias deben ser consideradas como recién instanciadas, si se establece a <literal>any</literal>, o separadas, si se establece a <literal>none</literal>. Lo mejor Indicates that transient instances should be considered newly instantiated, if set to <literal>any</literal>, or detached, if set to <literal>none</literal>. Lo mejor en todos los casos es dejar el valor por defecto."
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr "discriminator"
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr "El elemento <literal><discriminator></literal> es requerido para la persistencia polimórfica usando la estrategia de mapeo de tabla-por-jerarquía-de-clases y declara una columna discriminadora de la tabla. La columna discriminidora contiene valores de marca que le dicen a la capa de persistencia qué subclase instanciar para una fila en particular. Un conjunto restringido de tipos puede ser usado: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr "<literal>column</literal> (opcional - por defecto a <literal>class</literal>) el nombre de la columna discriminadora."
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr "<literal>type</literal> (opcional - por defecto a <literal>string</literal>) un nombre que indique el tipo Hibernate"
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr "<literal>force</literal> (optconal - por defecto a <literal>false</literal>) \"fuerza\" a Hibernate a especificar valores discriminadores permitidos incluso cuando se recuperan todas las instancias de la clase raíz."
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "<literal>insert</literal> (opcional - por defecto a <literal>true</literal>) establezca este a <literal>false</literal> si tu columna discriminadora es también parte de un identificador mapeado compuesto. (Le dice a Hibernate que no incluya la columna en los SQL <literal>INSERT</literal>s.)"
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr "<literal>formula</literal> (opcional) una expresión SQL arbitraria que es ejecutada cuando un tipo tenga que ser evaluado. Permite dicriminación basada en el contenido."
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr "Los valores reales de la columna discriminadora están especificados por el atributo <literal>discriminator-value</literal> de los elementos <literal><class></literal> y <literal><subclass></literal>."
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "El atributo <literal>force</literal> es (sólo) útil si la tabla contiene filas con valores discriminadores \"extra\" que no están mapeados a la clase persistente. Generalmente este no es el caso."
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr "Usando el atributo <literal>formula</literal> puedes declarar una expresión SQL arbitraria que será usada para evaluar el tipo de una fila:"
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr "version (opcional)"
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr "El elemento <literal><version></literal> es opcional e indica que la tabla contiene datos versionados. Esto es particularmente útil si planeas usar <emphasis>transacciones largas</emphasis> (ver debajo)."
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr "<literal>column</literal> (opcional - por defecto al nombre de la propiedad): El nombre de la columna que tiene el número de versión."
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr "<literal>name</literal>: El nombre de una propiedad de la clase persistente."
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr "<literal>type</literal> (opcional - por defecto a <literal>integer</literal>): El tipo del nú.mero de vesión."
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr "<literal>unsaved-value</literal> (opcional - por defecto a <literal>undefined</literal>): Un valor de la propiedad de versión que indica que una instancia está recién instanciada (sin guardar), distinguiéndola de instancias separadas que fueran guardadas o cargadas en una sesión previa. (<literal>undefined</literal> especifica que debe usarse el valor de la propiedad identificadora.)"
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr "Los números de versión deben ser de tipo <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> o <literal>calendar</literal> de Hibernate."
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr "Una propiedad de versión o timestamp nunca debe ser nula para una instancia separada, de modo que Hibernate detectará cualquier instancia con una versión o timestamp nulo como transitoria, sin importar qué otras estrategias <literal>unsaved-value</literal> se hayan especificado. <emphasis>Declarar una propiedad de versón o timestamp nulable es una forma fácil de evitar cualquier problema con la re-unión transitiva en Hibernate, especialmente útil para que usa identificadores asignados o claves compuestas!</emphasis>"
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr "timestamp (opcional)"
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr "El elemento opcional <literal><timestamp></literal> indica que la tabla contiene datos con sellos de tiempo. Esto esta concebido como una alternativa al versionado. Los timestamps (sellos de tiempo) son por su naturaleza una implementación menos segura de bloqueo optimista. Sin embrago, a veces la aplicación puede usar los timestamps en otras formas."
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr "<literal>column</literal> (opcional - por defecto al nombre de la propiedad): El nombre de una columna que tiene el timestamp."
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal>name</literal>: El nombre de una propiedad del estilo JavaBeans de tipo Java <literal>Date</literal> o <literal>Timestamp</literal> de la clase persistente."
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr "<literal>unsaved-value</literal> (opcional - por defecto a <literal>null</literal>): Un valor de propiedad de versión que indica que una instancia está recién instanciada (sin guardar), distinguiéndola de instancias separadas que hayan sido guardadas o cargadas en una sesión previa. (<literal>undefined</literal> especifica que debe usarse el valor de la propiedad identificadora.)"
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>."
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "property"
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr "El elemento <literal><property></literal> declara una propiedad persistente estilo JavaBean de la clase."
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "<literal>name</literal>: el nombre de la propiedad, con la letra inicial en minúsculas."
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr "<literal>column</literal> (opcional - por defecto al nombre de la propiedad): el nombre de la columna de tabla de base de datos mapeada. Esto puede también ser especificado con elemento(s) <literal><column></literal> anidado(s)."
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr "<literal>type</literal> (opcional): un nombre que indica el nobre Hibernate."
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr "<literal>update, insert</literal> (opcional - por defecto a <literal>true</literal>) : especifica que las columnas mapeadas deben ser incluídas en las sentencias SQL <literal>UPDATE</literal> y/o <literal>INSERT</literal> . Especificando ambas a <literal>false</literal> permite una propiedad \"derivada\" cuyo valor es inicializado desde alguna otra propiedad que mapee a la misma columna (o columnas) o por un disparador u otra aplicación."
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr "<literal>lazy</literal> (opcional - por defecto a <literal>false</literal>): Especifica que esta propiedad debe ser traída perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentación en tiempo de compilación)."
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr "<literal>unique</literal> (opcional): Habilita la generació DDL de una restricción de unicidad para las columnas. Además, permite que ésta sea un blanco objetivo de una <literal>property-ref</literal>."
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr "<literal>not-null</literal> (opcional): Habilita la generació DDL de una restricción de nulabilidad para las columnas."
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica que las actualizaciones a esta propiedad requieran o no de la obtención de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versión cuando la propiedad este sucia (desactualizada)."
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr "<emphasis>typename</emphasis> puede ser:"
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr "El nombre de un tipo básico Hibernate (por ejemplo, <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr "El nombre de una clase Java de tipo básico (por ejemplo, <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr "El nombre de una clase Java serializable."
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr "El nombre de un tipo personalizado (por ejemplo, <literal>com.illflow.type.MyCustomType</literal>)."
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr "Si no especificas un tipo, Hibernate usará reflección sobre la propiedad mencionada para deducir el tipo Hibernate correcto. Hibernate intentará interpretar el nombre de la clase de retorno del getter de la propiedad usando las reglas 2, 3 y 4 en ese orden. Sin embargo, esto no siempre suficiente. En ciertos casos, necesitarás aún el atributo <literal>type</literal>. (Por ejemplo, para distinguir entre <literal>Hibernate.DATE</literal> y <literal>Hibernate.TIMESTAMP</literal>, o especificar un tipo personalizado.)"
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "El atributo <literal>access</literal> te deja controlar cómo Hibernate accederá a la propiedad en tiempo de ejecución. Por defecto, Hibernate llamará al par de getter/setter de la propiedad. Si especificas <literal>access=\"field\"</literal>, Hibernate se saltará el par get/set y accederá al campo directamente usando reflección. Puedes especificar tu propia estrategia de acceso a la propiedad mencionando una clase que implemente la interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr "Una aspecto especialmente poderoso son las propiedades derivadas. Estas propiedades son por definición de sólo lectura, el valor de la propiedad es computado en tiempo de carga. Tu declaras la computación como una expresión SQL, y ésta se traduce a cláusula de subconsulta <literal>SELECT</literal> en la consulta SQL que cargue una instancia:"
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr "Observa que puedes referenciar la propia tabla de las entidades sin declarar un alias o una columna particular (<literal>customerId</literal> en el ejemplo dado). Observa además que puedes usar el elemento anidado de mapeo <literal><formula></literal> si no te gusta usar el atributo."
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr "many-to-one"
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "Una asociación ordinaria a otra clase persistente se declara usando el elemento <literal>many-to-one</literal>. El modelo relacional es una asociación muchos-a-uno: una clave foránea en una tabla está referenciando la columna (o columnas) de la clave primaria de la tabla objetivo."
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"true|proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"cualquier expresión SQL\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr "<literal>name</literal>: El nombre de la propiedad."
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr "<literal>column</literal> (opcional): El nombre de la columna clave foránea. También puede ser especificado por uno o varios elementos anidados <literal><column></literal>."
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "<literal>cascade</literal> (opcional): Especifica qué operaciones deben ir en cascada desde el objeto padre al objeto asociado"
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>fetch</literal> (opcional - por defecto a 1<literal>select</literal>): Escoge entre recuperación outer-join o por selección secuencial."
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr "<literal>update, insert</literal> (opcional - por defecto a <literal>true</literal>) especifica que las columnas mapeadas deben ser incluídas en las sentencias SQL <literal>UPDATE</literal> y/o <literal>INSERT</literal>. Establecer ambas a <literal>false</literal> permite una asociación puramente \"derivada\" cuyo valor es inicializado desde alguna otra propiedad que mapea a las misma columna (o columnas), o por un disparador, o por otra aplicación."
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "<literal>property-ref</literal>: (opcional) El nombre de la propiedad de la clase asociada que está unida a la clave foránea. Si no se especifica, se usa la clave primaria de la clase asociada."
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr "<literal>unique</literal> (opcional): Habilita la generación DDL de una restricción de unicidad para la columna de clave foránea. Además, permite que ésta sea el objetivo de una <literal>property-ref</literal>. Esto hace efectivamente la multiplicidad de la asociación uno a uno."
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr "<literal>not-null</literal> (opcional): Habilita la generación DDL de una restricción de nulabilidad para las columnas de clave foránea."
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica que las actualizaciones a esta propiedad requieran o no la obtención del bloqueo optimista. En otras palabras, determina si debe darse un incremento de versión cuando esta propiedad esté desactualizada."
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr "<literal>lazy</literal> (opcional - por defecto a <literal>proxy</literal>): Por defecto, las asociaciones de punto único van con proxies. <literal>lazy=\"true\"</literal> especifica que esta propiedad debe ser traída perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentación del bytecode en tiempo de compilación). <literal>lazy=\"false\"</literal> especifica que la asociación siempre será recuperada tempranamente."
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "<literal>not-found</literal> (opcional - por defecto a <literal>exception</literal>): Especifica cómo deben manejarse las claves foráneas que referencien filas inexistentes: <literal>ignore</literal> tratará una fila perdida como una asociación nula."
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "<literal>formula</literal> (opcional): una expresión SQL que define el valor para una clave foránea <emphasis>computada</emphasis>."
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr "Establecer el valor del atributo <literal>cascade</literal> a cualquier valor significativo distinto de <literal>none</literal> propagará ciertas operaciones al objeto asociado. Los valores significativos son los nombres de las operaciones básicas de Hibernate, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, así como los valores especiales <literal>delete-orphan</literal> y <literal>all</literal> y combinaciones de operaciones separadas por coma, por ejemplo, <literal>cascade=\"persist,merge,evict\"</literal> o <literal>cascade=\"all,delete-orphan\"</literal>. Para una explicación completa, ver <xref linkend=\"objectstate-transitive\"/>."
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "Una declaración típica <literal>muchos-a-uno</literal> se parece a esto:"
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+
+#: index.docbook:1284
+msgid "property"
+msgstr "El atributo <literal>property-ref</literal> debe ser usado solamente para el mapeo de datos heredados donde una clave foránea referencia una clave única de la tabla asociada, distinta de la clave primaria. Este es un modelo relacional feo. Por ejemplo, supón que la clase <literal>Product</literal> tuviera un número único serial que no es la clave primaria. (El atributo <literal>unique</literal> controla la generación de DDL con la herramienta SchemaExport.)"
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr "Entonces el mapeo para <literal>OrderItem</literal> debería usar:"
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "Sin embargo, esto no esta ciertamente alentado."
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr "Si la clave única referenciada abarca múltiples propiedades de la entidad asociada, debes mapear las propiedades dentro de un elemento <literal><properties></literal>."
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "one-to-one"
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "Una asociación uno-a-uno a otra clase persistente se declara usando un elemento <literal>one-to-one</literal>."
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>name</literal>: El nombre de la propiedad."
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>class</literal> (opcional - por defecto al tipo de la propiedad determinado por reflección): El nombre de la clase asociada."
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr "<literal>cascade</literal> (opcional) especifica qué operaciones deben ir en cascada desde el objeto padre al objeto asociado."
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "<literal>constrained</literal> (opcional) especifica que una restricción de clave foránea de la tabla mapeada referencia a la tabla de la clase asociada. Esta opción afecta el orden en que van en cascada <literal>save()</literal> y <literal>delete()</literal>, y determina cuándo la asociación pueden ser virtualizados por proxies (es también usado por la herramienta de exportación de esquemas)."
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>fetch</literal> (opcional - por defecto <literal>select</literal>): Elige entre recuperación outer-join o recuperación por consulta secuencial."
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr "<literal>property-ref</literal>: (opcional) El nombre de una propiedad de la clase asociada que esté unida a la clave primaria de esta clase. Si no se especifica, se usa la clave primaria de la clase asociada."
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr "<literal>formula</literal> (opcional): Casi todas las asociaciones uno-a-uno mapean a la clave primaria de la entidad propietaria. En el raro caso en que este no sea el caso, puedes especificar alguna otra columna, o columnas, o expresión para unir usando una fórmula SQL. (Para un ejemplo ver <literal>org.hibernate.test.onetooneformula</literal>)."
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr "<literal>lazy</literal> (opcional - por defecto a <literal>proxy</literal>): Por defecto, las asociaciones de punto único van con proxies. <literal>lazy=\"true\"</literal> especifica que esta propiedad debe ser traída perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentación del bytecode en tiempo de compilación). <literal>lazy=\"false\"</literal> especifica que la asociación siempre será recuperada tempranamente. <emphasis>Observa que si <literal>constrained=\"false\"</literal>, la aplicación de proxies es imposible e Hibernate traerá temprano la asociación!</emphasis>"
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr "Hay dos variedades de asociaciones uno-a-uno:"
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr "asociaciones de clave primaria"
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "asociaciones de clave foráneas única"
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "Las asociaciones de clave primaria no necesitan una columna de tabla extra; si dos filas están relacionadas por la asociación entonces las dos filas de tablas comparten el mismo valor de clave primaria. Por lo tanto, si quieres que dos objetos estén relacionados por una asociación de clave primaria, debes asegurarte que se les asigne el mismo valor de identificador!"
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr "Para una asociación de clave primaria, añade los siguientes mapeos a <literal>Employee</literal> y <literal>Person</literal>, respectivamente."
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "Ahora debemos asegurarnos que las claves primarias de las filas relacionadas en las tablas PERSON y EMPLOYEE sean iguales. Usamos una estrategia especial de generación de identificador de Hibernate llamada <literal>foreign</literal>:"
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr "A una instancia recién salvada de <literal>Person</literal> se le asigna entonces el mismo valor de clave primaria con que la instancia <literal>Employee</literal> referida por la propiedad <literal>employee</literal> de esta <literal>Person</literal>."
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "Alternativamente, una clave foránea con una restricción de unicidad, desde <literal>Employee</literal> a <literal>Person</literal>, puede ser expresada como:"
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "Y esta asociación puede hacerse bidireccional agregando lo siguiente al mapeo de <literal>Person</literal> :"
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "natural-id"
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr "Recomendamos fuertemente que implementes <literal>equals()</literal> y <literal>hashCode()</literal> para comparar las propiedades de clave natural de la entidad."
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr "Este mapeo no está concebido para usar con entidades con claves primarias naturales."
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr "<literal>mutable</literal> (opcional, por defecto a <literal>false</literal>): Por defecto, se asume que las propiedades de identificadores naturales son inmutables (constantes)."
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "component, dynamic-component"
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "El elemento <literal><component></literal> mapea propiedades de un objeto hijo a columnas de la tabla de la clase padre. Los componentes pueden a su vez declarar sus propias propiedades, componentes o colecciones. Ver debajo \"Componentes\"."
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr ""
+ "<![CDATA[<component \n"
+ " name=\"propertyName\" \n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ " \n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr "<literal>name</literal>: El nombre de la propiedad."
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr "<literal>class</literal> (opcional - por defecto al tipo de la propiedad determinado por reflección): El nombre de la clase del componente (hijo)."
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr "<literal>insert</literal>: Aparecen las columnas mapeadas en <literal>INSERT</literal>s SQL?"
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr "<literal>update</literal>: Aparecen las columnas mapeadas en <literal>UPDATE</literal>s SQL?"
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr "<literal>lazy</literal> (opcional - por defecto a <literal>false</literal>): Especifica que este componente debe ser recuperado perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentación de bytecode en tiempo de compilación)."
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica si las actualizaciones de este componente requieren o no la adquisición de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versión cuando esta propiedad está desactualizada."
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr "<literal>unique</literal> (opcional - por defecto a <literal>false</literal>): Especifica que existe una restricción de unicidad sobre todas las columnas mapeadas del componente."
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr "Las etiquetas hijas <literal><property></literal> mapean propiedades de la clase hija columnas de la tabla."
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr "El elemento <literal><component></literal> permite un subelemento <literal><parent></literal> que mapea una propiedad de la clase del componente como una referencia de regreso a la entidad contenedora."
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr "El elemento <literal><dynamic-component></literal> permite que un <literal>Map</literal> sea mapeado como un componente, donde los nombres de las propiedades se corresponden a las claves del mapa, ver <xref linkend=\"components-dynamic\"/>."
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr "properties"
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr "El elemento <literal><properties></literal> permite la definición de un grupo de propiedades lógico con nombre de una clase. El uso más importante de la contrucción es que permite que una combinación de propiedades sea objetivo de una <literal>property-ref</literal>. Es también una forma conveniente de definir una restricción de unicidad multicolumna."
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr ""
+ "<![CDATA[<properties \n"
+ " name=\"logicalName\" \n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ " \n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "<literal>name</literal>: El nombre lógico del agrupamiento - <emphasis>no</emphasis> un nombre de propiedad real."
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica si las actualizaciones de estas propiedades requieren o no de la adquisición de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versión cuando estas propiedades están desactualizadas."
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr "<literal>unique</literal> (opcional - por defecto a <literal>false</literal>): Especifica que existe una restricción de unicidad sobre todas las columnas mapeadas del componente."
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\" \n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"person\" \n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr "No recomendamos el uso de este tipo de cosas fuera del contexto del mapeo de datos heredados."
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr "Finalmente, la persistencia polimórfica requiere la declaración de la clase persistente raíz. Para la estrategia de mapeo tabla-por-jerarquía-de-clases, se usa la declaración de <literal><subclass></literal>."
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr "<literal>name</literal>: El nombre de clase cualificado completamente de la subclase."
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr "<literal>discriminator-value</literal> (opcional - por defecto al nombre de la clase): Un valor que distingue a subclases individuales."
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr "<literal>proxy</literal> (opcional): Especifica una clase o interface a usar para proxies de inicialización perezosa."
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr "<literal>lazy</literal> (opcional, por defecto a <literal>true</literal>): Establecer <literal>lazy=\"false\"</literal> deshabilita el uso de recuperación perezosa."
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr "Cada subclase debe declarar sus propias propiedades persistentes y subclases. Se asume que las propiedades <literal><version></literal> y <literal><id></literal> son heredadas de la clase raíz. Cada subclase en una jerarquía debe definir un <literal>discriminator-value</literal> único. Si no se especifica ninguno, se usa el nombre completamente cualificado de clase Java."
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "Es posible definir mapeos <literal>subclass</literal>, <literal>union-subclass</literal>, y <literal>joined-subclass</literal> en documentos de mapeo separados, directamente debajo de <literal>hibernate-mapping</literal>. Esto te permite extender una jerarquía de clases con sólo agregar un nuevo fichero de mapeo. Debes especificar un atributo <literal>extends</literal> en el mapeo de la subclase, mencionando una superclase previamente mapeada. Nota: Previamente esta funcionalidad hacía importante el orden de los documentos de mapeo. Desde Hibernate3, el orden de los ficheros de mapeo no importa cuando se usa la palabra reservada extends. El orden dentro de un mismo fichero de mapeo todavía necesita ser definido como superclases antes de subclases."
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "Para información acerca de mapeos de herencia, ver <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr "joined-subclass"
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr "Alternativamente, cada subclase puede ser mapeada a su propia tabla (estrategia de mapeo tabla-por-subclase). El estado heredado se recupera uniendo con la tabla de la superclase. Usamos el elemento <literal><joined-subclass></literal>."
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr "<literal>name</literal>: El nombre de clase completamente cualificado de la subclase."
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr "<literal>table</literal>: El nombre de tabla de la subclase."
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr "<literal>proxy</literal> (opcional): Especifica una clase o interface a usar para proxies de inicializacón perezosa."
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr "<literal>lazy</literal> (opcional, por defecto a <literal>true</literal>): Establecer <literal>lazy=\"false\"</literal> deshabilita el uso de recuperación perezosa."
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "No se requiere de una columna discriminadora para esta estrategia de mapeo. Cada subclase debe, sin embargo, declarar una columna de tabla que tenga el identificador del objeto usando el elemento <literal><key></literal>. El mapeo del comienzo del capítulo debería ser reescrito como:"
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr "Para información acerca de mapeos de herencia, ver <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr "union-subclass"
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr "Una tercera opción es mapear sólo las clases concretas de una jerarquía de clases a tablas, (la estrategia tabla-por-clase-concreta) donde cada tabla define todo el estado persistente de la clase, incluyendo el estado heredado. En Hibernate, no es absolutamente necesario mapear dichas jerarquías de herencia. Puedes simplemente mapear cada clase con una declaración <literal><class></literal> separada. Sin embargo, si deseas usar asociaciones polimórficas (por ejemplo, una asociación a la superclase de tu jerarquía), debes usar el mapeo <literal><union-subclass></literal>."
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr "<literal>table</literal>: El nombre de tabla de la subclase."
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr "<literal>proxy</literal> (optional): Especifica una clase o interface a usar para proxies de inicializacón perezosa."
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr "<literal>lazy</literal> (opcional, por defecto a <literal>true</literal>): Establecer <literal>lazy=\"false\"</literal> deshabilita el uso de recuperación perezosa."
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "Para información acerca de mapeos de herencia, ver <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "join"
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "Usando el elemento <literal><join></literal>, es posible mapear propiedades de una clase a varias tablas."
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ " \n"
+ " <key ... />\n"
+ " \n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal>table</literal>: El nombre de la clase unida."
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr "<literal>schema</literal> (opcional): Sobrescribe el nombre de esquema especificado por el elemento raíz <literal><hibernate-mapping></literal>."
+
+#: index.docbook:1928
+msgid "properties"
+msgstr "<literal>catalog</literal> (opcional): Sobrescribe el nombre de catálogo especificado por el elemento raíz <literal><hibernate-mapping></literal>."
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr "<literal>fetch</literal> (opcional - por defecto a <literal>join</literal>): Si se establece a <literal>join</literal>, por defecto, Hibernate usará una unión interior (inner join) para recuperar un <literal><join></literal> definido por una clase o sus superclases y una unión externa (outer join) para un <literal><join></literal> definido por una subclase. Si se establece a <literal>select</literal>, entonces Hibernate usará una select secuencial para un <literal><join></literal> definido en una subclase, que será publicada sólo si una fila resulta representar una instancia de la subclase. Las uniones interiores todavía serán usados para recuperar un <literal><join></literal> definido por la clase y sus superclases."
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr "<literal>inverse</literal> (opcional - por defecto a <literal>false</literal>): De habilitarse, Hibernate no intentará insertar o actualizar las propiedades definidas por esta unión."
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr "<literal>optional</literal> (opcional - por defecto a <literal>false</literal>): De habilitarse, Hibernate insertará una fila sólo si las propiedades definidas por esta unión son no nulas y siempre usará una unión externa para recuperar las propiedades."
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr "Esta funcionalidad es a menudo solamente útil para modelos de datos heredados; recomendamos menos tablas que clases un modelo de dominio más granularizado. Sin embargo, es útil para cambiar entre estrategias de mapeo de herencias en una misma jerarquía, como se explica luego."
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr "Hasta ahora hemos visto el elemento <literal><key></literal> pocas veces. Aparece en cualquier sitio en que el elemento padre de mapeo defina una unión a una nueva tabla, y define la clave foránea en la tabla unida, que referencia la clave primaria de la tabla original."
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "<literal>column</literal> (opcional): El nombre de columna de la clave foránea. Puede ser también especificado por elemento(s) anidado(s) <literal><column></literal>."
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr "<literal>on-delete</literal> (opcional, por defecto a <literal>noaction</literal>): Especifica si la restricción de clave foránea tiene el borrado en cascada habilitado a nivel de base de datos."
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr "<literal>property-ref</literal> (opcional): Especifica que la clave foránea referencia columnas que no son del la clave primaria de la tabla original. (Provisto para datos heredados.)"
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr "<literal>not-null</literal> (opcional): Especifica que las columnas de la clave foránea son no nulables (esto está implicado si la clave foránea es también parte de la clave primaria)."
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr "<literal>update</literal> (opcional): Especifica que la clave foránea nunca debe ser actualizada (esto está implicado si la clave foránea es también parte de la clave primaria)."
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr "<literal>unique</literal> (opcional): Especifica que la clave foránea debe tener una restricción de unicidad (esto está implicado si la clave foránea es también la clave primaria)."
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr "Recomendamos que, para los sistemas en donde el rendimiento sea importante, todas las claves deben ser definidas <literal>on-delete=\"cascade\"</literal>, e Hibernate usará una restricción <literal>ON CASCADE DELETE</literal> a nivel de base de datos, en vez de muchas sentencias <literal>DELETE</literal> individuales. Ten en cuenta que esta funcionalidad se salta la habitual estrategia de bloqueo optimista de Hibernate para datos versionados."
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr "Los atributos <literal>not-null</literal> y <literal>update</literal> son útiles al mapear una asociación uno a muchos unidireccional. Si mapeas una uno a muchos unidireccional a una clave foránea no nulable, <emphasis>debes</emphasis> declarar la columna clave usando <literal><key not-null=\"true\"></literal>."
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr "los elementos column y formula"
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "Cualquier elemento de mapeo que acepte un atributo <literal>column</literal> aceptará alternativamente un subelemento <literal><column></literal>. De forma similar, <literal><formula></literal> es una alternativa al atributo <literal>formula</literal>."
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"/>]]>"
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr "<![CDATA[<formula>expresión SQL</formula>]]>"
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr "Los atributos <literal>column</literal> y <literal>formula</literal> pueden incluso ser combinados dentro del mismo mapeo de propiedad o asociación para expresar, por ejemplo, condiciones de unión exóticas."
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr "import"
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr "<literal>rename</literal> (opcional - por defecto al nombre de clase sin cualificar): Un nombre que será usado en el leguaje de consulta."
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "<title>any</title>"
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr "El atributo <literal>meta-type</literal> permite a la aplicación especificar un tipo personalizado que mapee columnas de base de datos a clases persistentes que tengan propiedades identificadoras del tipo especificado por <literal>id-type</literal>. Debes especificar el mapeo de valores del meta-type a nombres de clase."
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que Hibernate debe usar para acceder al valor de la propiedad."
+
+#: index.docbook:2179
+msgid "join"
+msgstr "Tipos de Hibernate"
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr "Entidades y Valores"
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr "Para entender el comportamiento de varios objetos a nivel de lenguaje Java con respecto al servicio de persistencia, necesitamos clasificarlos en dos grupos:"
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr "Una <emphasis>entidad</emphasis> existe independientemente de cualquier otros objetos que referencien a la entidad. Contrasta esto con el model habitual de Java donde un objeto desreferenciado es recolectado como basura. Las entidades deben ser salvadas y borradas explícitamente (excepto que las grabaciones y borrados puedan ser <emphasis>tratados en cascada</emphasis> desde una entidad padre a sus hijos). Esto es diferente al modelo de persistencia de objetos por alcance - y se corresponde más de cerca a cómo los objetos de aplicación son usados habitualmente en grandes sistemas. Las entidades soportan referencias circulares y compartidas, que tambié pueden ser versionadas."
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr "Volveremos a visitar ambos conceptos a lo largo de la documentación."
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr "EL desafío es mapear el sistema de tipos de Java (y la definición de entidades y tipos de valor de los desarrolladores) al sistema de tipos de SQL/base de datos. EL puente entre ambos sistemas es provisto por Hibernate: para las entidades usamos <literal><class></literal>, <literal><subclass></literal>, etc. Para los tipos de valor usamos <literal><property></literal>, <literal><component></literal>, etc, usualmente con un atributo <literal>type</literal>. El valor de este atributo es el nombre de un <emphasis>tipo de mapeo</emphasis> de Hibernate. Hibernate provee de fábrica muchos mapeos (para tipos de valores del JDK estándar). Puedes escribir tus propios mapeos de tipo, así como implementar tus estrategias de conversión personalizadas, como veremos luego."
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr "Todos los tipos prefabricados de Hibernate soportan semántica de nulos excepto las colecciones."
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr "Tipos de valores básicos"
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr "Los <emphasis>tipos de mapeo básicos</emphasis> prefabricados pueden ser categorizado a grandes rasgos en:"
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr "Mapeos de tipos primitivos de Java o clases de envoltura a la tipos de columna SQL (especícifica del vendedor). <literal>boolean, yes_no</literal> y <literal>true_false</literal> son codificaciones alternativas a <literal>boolean</literal> de Java o <literal>java.lang.Boolean</literal>."
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr "string"
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr "Un mapeo del tipo <literal>java.lang.String</literal> a <literal>VARCHAR</literal> (u Oracle <literal>VAARCHAR2</literal>)."
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr "Mapeos de tipo desde <literal>java.util.Date</literal> y sus subclases a tipos SQL <literal>DATE</literal>, <literal>TIME</literal> y <literal>TIMESTAMP</literal> (o equivalente)."
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr "calendar, calendar_date"
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "Mapeos de tipo desde <literal>java.util.Date</literal> y sus subclases a tipos SQL <literal>TIMESTAMP</literal> y <literal>DATE</literal> (o equivalente)."
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "big_decimal, big_integer"
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr "Mapeos de tipo desde <literal>java.math.BigDecimal</literal> y <literal>java.math.BigInteger</literal> a <literal>NUMERIC</literal> (o <literal>NUMBER</literal> de Oracle)."
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "locale, timezone, currency"
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr "Mapeos de tipo desde <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> y <literal>java.util.Currency</literal> a <literal>VARCHAR</literal> (o <literal>VARCHAR2</literal> de Oracle). Las instancias de <literal>Locale</literal> y <literal>Currency</literal> son mapeadas a sus códigos ISO. Las instancias de <literal>TimeZone</literal> son mapeadas a sus <literal>ID</literal>."
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr "<literal>class</literal>"
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr "Un mapeo de tipo <literal>java.lang.Class</literal> a <literal>VARCHAR</literal> (o <literal>VARCHAR2</literal> de Oracle). Una <literal>Class</literal> es mapeara a su nombre completamente cualificado."
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr "binary"
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr "Mapea arreglos de bytes a un tipo binario SQL apropiado."
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "text"
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr "Mapea cadenas largas Java al tipo SQL <literal>CLOB</literal> o <literal>TEXT</literal>."
+
+#: index.docbook:2367
+msgid "import"
+msgstr "serializable"
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr "Mapea tipos serializables Java a un tipo binario SQL apropiado. Puedes además indicar el tipo <literal>serializable</literal> de Hibernate con el nombre de una clase o interface serializable Java que no sea por defecto un tipo básico."
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr "clob, blob"
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr "Mapeos de tipo para las clases JDBC <literal>java.sql.Clob</literal> y <literal>java.sql.Blob</literal>. Estos tipos pueden ser inconvenientes para algunas aplicaciones, pues el objeto blob o clob no puede ser reusado fuera de una transacción (Además, el soporte del driver suele ser malo e inconsistente)."
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr "Los identificadores únicos de entidades y collecciones pueden ser de cualquier tipo básico excepto <literal>binary</literal>, <literal>blob</literal> y <literal>clob</literal>. (Los identificadores compuestos están también permitidos, ver debajo.)"
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr "Los tipos de valor básicos tienen sus constantes <literal>Type</literal> correspondientes definidas en <literal>org.hibernate.Hibernate</literal>. Por ejemplo, <literal>Hibernate.STRING</literal> representa el tipo <literal>string</literal>."
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr "Tipos de valor personalizados"
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr "Es relativamente fácil para los desarrolladores crear sus propios tipos de valor. Por ejemplo, podrías querer persistir propiedades del tipo <literal>java.lang.BigInteger</literal> a columnas <literal>VARCHAR</literal>. Hibernate no provee un tipo de fábrica para esto. Pero los tipos personalizados no están limitados a mapear una propiedad (o elemento de colección) a una sola columna de tabla. Así, por ejemplo, podrías tener una propiedad Java <literal>getName()</literal>/<literal>setName()</literal> de tipo <literal>java.lang.String</literal> que fuera persistida a las columnas <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "Para implementar un tipo personalizado, implementa bien <literal>org.hibernate.UserType</literal> o <literal>org.hibernate.CompositeUserType</literal> y declara las propiedades usando el nombre de clase completamente cualificado del tipo. Revisa <literal>org.hibernate.test.DoubleStringType</literal> para ver qué tipo de cosas son posibles."
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr "Observa el uso de etiquetas <literal><column></literal> para mapear una propiedad a múltiples columnas."
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr "Las interfaces <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, y <literal>UserVersionType</literal> proveen soporte a usos más especializados."
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr "Puedes incluso proveer de parámetros a un <literal>UserType</literal> en el fichero de mapeo. Para hacer esto, tu <literal>UserType</literal> debe implementar la interface <literal>org.hibernate.usertype.ParameterizedType</literal>. Para proveer de parámetros a tu tipo personalizado, puedes usar el elemento <literal><type></literal> en tus ficheros de mapeo."
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "Ahora el <literal>UserType</literal> puede recuperar el valor del parámetro llamado <literal>default</literal> del objeto <literal>Properties</literal> que se le pasa."
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr "también es posible sobrescribir los parámetros provistos en un typedef sobre una base caso por caso usando parámetros de tipo en el mapeo de la propiedad."
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr "Aunque el rico espectro de tipos prefabricados y soporte de componentes de Hibernate significa que raramente <emphasis>necesites</emphasis> usar un tipo personalizado; sin embargo se considera una buena forma usar tipos personalizados para clases (no-entidades) que aparezcan frecuentemente en tu aplicación. Por ejemplo, una clase <literal>MonetaryAmount</literal> es una buena candidata para un <literal>CompositeUserType</literal>, incluso cuando puede ser facilmente mapeada como un componente. Un motivo para esto es la abstracción. Con un tipo personalizado, tus documentos de mapeo estará impermeabilizados contra posibles cambios futuros en la forma de representar valores monetarios."
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr "Mapeando una clase más de una vez"
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "Es posible proveer más de un mapeo para una clase persistente en particular. En este caso debes especificar un <emphasis>nombre de entidad</emphasis> para desambiguar entr las instancias de las dos entidades mapeadas. (Por defectom, el nombre de la entidad es el mismo que el nombre de la clase.) Hibernate te deja especificar el nombre de entidad al trabajar con objetos persistentes, al escribir consultas, o al mapear asociaciones a la entidad mencionada."
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\" \n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\" \n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\" \n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\" \n"
+ " column=\"currentContractId\" \n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr "Observa cómo las asociaciones ahora se especifican usando <literal>entity-name</literal> en vez de <literal>class</literal>."
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr "identificadores SQL encomillados"
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr "Puedes forzar a Hibernate a encomillar un identificador en el SQL generado encerrando el nombre de tabla o columna entre backticks en el documento de mapeo. Hibernate usará el estilo de encomillado para el <literal>Dialect</literal> SQL (usualmente comillas dobles, excepto corchetes para SQL Server y backsticks para MySQL)."
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr "Alternativas de metadatos"
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr "XML no es para todos, asá que hay algunas formas alternativas de definir metadatos de mapeo O/R en Hibernate."
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "Usando marcado de XDoclet"
+
+#: index.docbook:2567
+msgid "string"
+msgstr "Muchos usuarios de Hibernate prefieren embeber la información de mapeo directamente en el código fuente usando las <literal>@hibernate.etiquetas</literal> XDoclet. No cubriremos este enfoque en este documento, pues estrictamente es considerado parte de XDoclet. Sin embargo, incluímos el siguiente ejemplo de la clase <literal>Cat</literal> con mapeos XDoclet."
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr "Para más ejemplos de XDoclet e Hibernate ver en el sitio web de Hibernate."
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr "Usando anotaciones JDK 5.0"
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr "El JDK 5.0 introdujo anotaciones del estilo XDoclet a nivel del lenguaje, con chequeo seguro de tipos en tiempo de compilación. Este mecanismo es más potente y que las anotaciones XDoclet, y mejor soportado por herramientas e IDEs. IntelliJ IDEA, por ejemplo, soporta auto-compleción y resaltado de sintaxis de anotaciones JDK 5.0. La nueva revisión de la especificación de EJB (JSR-220) usa anotaciones JDK 5.0 como el mecanismo primario de metadatos para beans de entidad. Hibernate3 implementa el <literal>EntityManager</literal> del JSR-220 (la API de persistencia), y el soporte para metadatos de mapeo está disponible vía el paquete <emphasis>Hibernate Annotations</emphasis>, como una descarga por separado. Tanto metadatos de EJB3 (JSR-220) como de Hibernate3 están soportados."
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "Este es un ejemplo de una clase POJO anotada como un bean de entidad EJB:"
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ "\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "Ten en cuenta que el soporte a anotaciones JDK 5.0 (y JSR-220) es todavía un trabajo en progreso y no completado. Por favor, para más detalles refiérete al modulo de Anotaciones de Hibernate."
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr ""
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr ""
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr ""
+
+#: index.docbook:2630
+msgid "binary"
+msgstr ""
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr ""
+
+#: index.docbook:2638
+msgid "text"
+msgstr ""
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr ""
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr ""
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr ""
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr ""
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr ""
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr ""
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr ""
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr ""
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr ""
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr ""
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr ""
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr ""
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr ""
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr ""
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr ""
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr ""
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr ""
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr ""
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr ""
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr ""
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr ""
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr ""
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr ""
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr ""
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr ""
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,342 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr "Procesamiento por lotes"
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr "Un enfoque ingenuo para insertar 100.000 filas en la base de datos usando Hibernate podrÃa verse asÃ:"
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr "Esto podrÃa caer sobre una <literal>OutOfMemoryException</literal> en algún sitio cerca de la fila 50.000. Esto es porque Hibernate tiene en caché todas las instancias de <literal>Customer</literal> recién instanciadas en el caché de nivel de sesión."
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr "En este capÃtulo te mostraremos cómo evitar este problema. Primero, sin embargo, si estás haciendo procesamiento por lotes (batch processing), es absolutamente crÃtico que habilites el uso de loteo JDBC, si pretendes lograr un rendimiento razonable. Establece el tamaño de lote JDBC a un número razonable (digamos 10-50):"
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr "PodrÃas además querer hacer este tipo de trabajo en un proceso donde la interacción con el caché de segundo nivel esté completamente deshabilitado:"
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr "Inserciones en lote"
+
+#: index.docbook:41
+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 "Al hacer persistentes objetos nuevos, debes limpiar con <literal>flush()</literal> y llamar a <literal>clear()</literal> en la sesión regularmente, para controlar el tamaño del caché de primer nivel."
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr "Actualizaciones en lote"
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Para recuperar y actualizar datos se aplican las mismas ideas. Adicionalmente, necesitas usar <literal>scroll()</literal> para sacar ventaja de los cursores del lado del servidor en consultas que devuelvan muchas filas de datos."
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:62
+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 "update/delete en masa"
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Como ya se ha discutido, el mapeo objeto/relacional automático y transparente se refiere al manejo de estado de objetos. Esto implica que el estado del objeto está disponible en memoria, por lo tanto actualizar o borrar (usando <literal>UPDATE</literal> y <literal>DELETE</literal> de SQL) datos directamente en la base de datos no afectará el estado en memoria. Sin embargo, Hibernate provee métodos para la ejecución de sentencias del estilo de <literal>UPDATE</literal> y <literal>DELETE</literal> de SQL que se realizan a través del Lenguaje de Consulta de Hibernate (Hibernate Query Language o <xref linkend=\"queryhql\"/>HQL)."
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr "La pseudo-sintáxis para sentencias <literal>UPDATE</literal> y <literal>DELETE</literal> es: <literal>( UPDATE | DELETE ) FROM? ClassName (WHERE WHERE_CONDITIONS)?</literal>. Algunos puntos a tener en cuenta:"
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr "En la cláusula-from, la palabra clave FROM es opcional"
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Puede haber sólo una clase mencionada en la cláusula-from, y <emphasis>no puede</emphasis> tener un alias."
+
+#: index.docbook:91
+msgid "Note that 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 "No puede especificarse ningún join (bien implÃcito o explÃcito) en una consulta masiva de HQL. Pueden usarse subconsultas en la cláusula-where."
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr "La cláusula-where es también opcional."
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr "Como un ejemplo, para ejecutar un <literal>UPDATE</literal> HQL, usa el método <literal>Query.executeUpdate()</literal>:"
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ " int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ " tx.commit();\n"
+ " session.close();]]>"
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr "Para ejecutar un <literal>DELETE</literal> HQL, usa el mismo método <literal>Query.executeUpdate()</literal> (el método está nombrado para aquellos familiarizados con <literal>PreparedStatement.executeUpdate()</literal> de JDBC):"
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ " int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ " tx.commit();\n"
+ " session.close();]]>"
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 "El valor <literal>int</literal> devuelto por el método <literal>Query.executeUpdate()</literal> indica el número de entidades afectadas por la operación. Considera que esto puede o no correlacionarse al número de filas afectadas en la base de datos. Una operación masiva HQL podrÃa resultar en que se ejecuten múltiples sentencias de SQL reales, para joined-subclass, por ejemplo. El número devuelto indica el número de entidades reales afectadas por la sentencia. Volviendo al ejemplo de joined-subclass, un borrado contra una de las subclases puede resultar realmente en borrados contra no sólo la tabla a la que está mapeada esa subclase, sino también la tabla \"raÃz\" y potencialmente tablas de joined-subclass más debajo en la jerarquÃa de herencia."
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr "Ten en cuenta que existen actualmente unas pocas limitaciones con las operaciones HQL masivas, que serán atendidas en lanzamientos futuros; consulta la hoja de ruta de JIRA para más detalles."
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr ""
+
+#: index.docbook:156
+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 ""
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 ""
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr ""
+
+#: index.docbook:181
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr ""
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr ""
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr ""
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 ""
+
+#: index.docbook:220
+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. Note however that this might 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 ""
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ""
+
+#: index.docbook:247
+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 ""
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr "Mejores Prácticas"
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr "Escribe clase finamente granularizadas y mapealas usando <literal><component></literal>."
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr "Usa una clase <literal>Dirección</literal> para encapsular <literal>calle</literal>, <literal>distrito</literal>, <literal>estado</literal>, <literal>código postal</literal>. Esto alienta la reutilización de código y simplifica el refactoring."
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr "Declara las propiedades identificadoras en clases persistentes."
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr "Hibernate hace opcionales las propiedades identificadoras. Existen todo tipo de razones por las que debes usarlas. Recomendamos que los identificadores sean 'sintéticos' (generados, sin ningún significado de negocio)."
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr "Identifica las claves naturales."
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr "Identifica las claves naturales de todas las entidades, y mapealas usando <literal><natural-id></literal>. Implementa <literal>equals()</literal> y <literal>hashCode()</literal> para comparar las propiedades que componen la clave natural."
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr "Coloca cada mapeo de clase en su propio fichero."
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr "No uses un solo documento monolítico de mapeo. Mapea <literal>com.eg.Foo</literal> en el fichero <literal>com/eg/Foo.hbm.xml</literal>. Esto tiene sentido particularmente en un ambiente de equipo."
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr "Carga los mapeos como recursos."
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr "Despliega los mapeos junto a las clases que mapean."
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr "Considera externalizar las cadenas de consulta."
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr "Esta es una buena práctica si tus consultas llaman a funciones SQL que no son del estándar ANSI. Externalizar las cadenas de consulta a ficheros de mapeo hará la aplicación más portable."
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr "Usa variables de ligado."
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr "Igual que en JDBC, siempre remplaza valores no constantes con \"?\". ¡Nunca uses manipulación de cadenas para ligar un valor no constante en una consulta! Incluso mejor, considera usar parámetros con nombre en las consultas."
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr "No manejes tus propias conexiones JDBC."
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr "Hibernate deja a la aplicación administre las conexiones JDBC. Este enfoque debe considerarse como último recurso. Si no puedes usar los provedores de conexión prefabricados, considera prover tu propia implementación de <literal>org.hibernate.connection.ConnectionProvider</literal>."
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr "Considera usar un tipo personalizado."
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr "Supón que tienes un tipo Java, digamos de alguna biblioteca, que necesita hacerse persistente pero no provee los métodos de acceso necesarios para mapearlo como un componente. Debes considerar implementar <literal>org.hibernate.UserType</literal>. Este enfoque libera al código de aplicación de implementar transformaciones a / desde un tipo Hibernate."
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr "Usa JDBC codificado a mano en cuellos de botella."
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr "En áreas del sistema de rendimiento crítico, algunos tipos de operaciones podrían beneficiarse del JDBC directo. Pero por favor, espero hasta que <emphasis>sepas</emphasis> que algo es un cuello de botella. Y no asumas que el JDBC directo es necesariamente más rápido. Si necesitas usar JDBC directo, podría ser valioso abrir una <literal>Session</literal> de Hibernate y usar esa conexión JDBC. De esta forma puedes usar aún la misma estrategia de transacción y el mismo proveedor de conexiones subyacente."
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr "Comprende la limpieza (flushing) de <literal>Session</literal>."
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr "De vez en cuando la sesión sincroniza su estado persistente con la base de datos. El rendimiento se verá afectado si este proceso ocurre demasiado frecuentemente. A veces puedes minimizar limpieza innecesaria deshabilitando la limpieza automática o incluso cambiando el orden de las consultas u otras operaciones en una transacción en particular."
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr "En una aplicación en tres gradas, considera usar objetos separados."
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr "Al usar una arquitectura de servlet / sesión, puedes pasar objetos persistentes en el bean de sesión hacia y desde la capa de servlet / JSP. Usa una sesión nueva para atender el servicio de cada petición. Usa <literal>Session.merge()</literal> o <literal>Session.saveOrUpdate()</literal> para sincronizar los objetos con la base de datos."
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr "En una arquitectura en dos gradas, considera usar contexto de persistencia largos."
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr "Las transacciones de base de datos tienen que ser tan cortas como sea posible. Sin embargo, frecuentemente es necesario implementar <emphasis>transacciones de aplicación</emphasis> ejecutándose en largo, una sola unidad de trabajo desde el punto de vista de un usuario. Una transacción de aplicación puede abarcar muchos ciclos petición/respuesta del cliente. Es común usar objetos separados para implementar transacciones de aplicación. Una alternativa, extremadamente apropiada en arquitecturas en dos gradas, es mantener un solo contacto de persistencia abierto (sesión) para todo el ciclo de vida de la transacción de aplicación y simplemente desconectar de la conexión JDBC al final de cada petición, y reconectar al comienzo de la petición subsecuente. Nunca compartas una única sesión a través de más de una transacción de aplicación, o est!
arás trabajando con datos añejos."
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr "No trates la excepciones como recuperables."
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr "Esto es más una práctica necesaria que una \"mejor\" práctica. Cuando ocurra una excepción, deshaz (rollback) la <literal>Transaction</literal> y cierra la <literal>Session</literal>. Si no lo haces, Hibernate no puede garantizar que el estado en memoria representa con exactitud el estado persistente. Como un caso especial de esto, no uses <literal>Session.load()</literal> para determinar si una instancia con el identificador dado existe en la base de datos. En cambio, usa <literal>Session.get()</literal> o una consulta."
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr "Prefiere la recuperación perezosa para las asociaciones."
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr "Usa escasamente la recuperación temprana. Usa proxies y colecciones perezosas para la mayoría de asociaciones a clases probablemente no estén mantenidas en el caché de segundo nivel. Para las asociaciones a clases en caché, donde hay una probabilidad de acceso a caché extremadamente alta, deshabilita explícitamente la recuperación temprana usando <literal>lazy=\"false\"</literal>. Cuando sea apropiada la recuperación por unión (join fetching) para un caso de uso en particular, usa una consulta con un <literal>left join fetch</literal>."
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr "Usa el patrón <emphasis>sesión abierta en vista</emphasis>, o una <emphasis>fase de ensamblado</emphasis> disciplinada para evitar problemas con datos no recuperados."
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr "Hibernate liberal al desarrollador de escribir <emphasis>Objetos de Transferencia de Datos (Data Transfer Objects)</emphasis> (DTO). En una arquitectura tradicional de EJB, los DTOs tienen un propósito doble: primero, atacan el problema que los beans de entidad no son serializables. Segundo, definen implícitamente una fase de ensamblado cuando se recuperan y se forman (marshalling) todos los datos a usar por la vista en los DTOs antes de devolver el control a la grada de presentación. Hibernate elimina el primer propósito. Sin embargo, aún necesitas una fase de ensamblado (piensa en tus métodos de negocio como si tuviesen un contrato estricto con la grada de presentación sobre qué datos están disponibles en los objetos separados) a menos que estés preparado para tener el contexto de persistencia (la sesión) abierto a través del proceso de renderización de la vista. ¡Est!
a no es una limitación de Hibernate! Es un requerimiento fundamental de acceso seguro a datos transaccionales."
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr "Considera abstraer tu lógica de negocio de Hibernate"
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr "Oculta el código de acceso a datos (Hibernate) detrás de una interface. Combina los patrones <emphasis>DAO</emphasis> y <emphasis>Sesión de Hebra Local</emphasis>. Incluso puedes tener algunas clases hechas persistentes por JDBC escrito a mano, asociadas a Hibernate por medio de un <literal>UserType</literal>. (Este consejo está pensado para aplicaciones \"suficientemente grandes\"; ¡no es apropiado para una aplicación con cinco tablas!)"
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr "No uses mapeos de asociación exóticos."
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr "Son raros los casos de uso de asociaciones reales muchos-a-muchos. La mayor parte del tiempo necesitas información adicional almacenada en una \"tabla de enlace\". En este caso, es mucho mejor usar dos asociaciones uno-a-muchos a una clase de enlace intermedia. De hecho, pensamos que la mayoría de asociaciones son uno-a-muchos y muchos-a-uno, debes ser cuidadoso al usr cualquier otro estilo de asociación y preguntarte si es realmente necesario."
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr "Prefiere las asociaciones bidireccionales."
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr "Las asociaciones unidireccionales son más difíciles de consultar. En una aplicación grande, casi todas las asociaciones deben ser navegables en ambas direcciones en consultas."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1285 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr "Mapeo de Colecciones"
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr "Colecciones persistentes"
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr "Hibernate requiere que los campos valuados en colección persistentes sean declarados como un tipo de interface, por ejemplo:"
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr "La interface real podría ser <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> o ... lo que te guste! (Donde \"lo que te guste\" significa que tendrás que escribir una implementación de <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr "Nota cómo hemos inicializado la variable de instancia de <literal>HashSet</literal>. Esta es la mejor forma de inicializar propiedades valuadas en colección de instancias recién instanciadas (no persistentes). Cuando haces persistente la instancia - llamando a <literal>persist()</literal>, por ejemplo - Hibernate realmente remplazará el <literal>HashSet</literal> con una instancia de una implementación de <literal>Set</literal> propia de Hibernate. Observa errores como este:"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr "Las colecciones persistentes inyectadas por Hibernate se comportan como <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> o <literal>ArrayList</literal>, dependiendo del tipo de interface."
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr "Las instancias de colecciones tienen el comportamiento usual de tipos de valor. Son automáticamente persistidas al ser referenciadas por un objeto persistente y automáticamente borradas al desreferenciarse. Si una colección es pasada de un objeto persistente a otro, sus elementos serían movidos de una tabla a otra. Dos entidades pueden no compartir una referencia a la misma instancia de colección. Debido al modelo relacional subyacente, las propiedades valuadas en colección no soportan la semántica de valor nulo. Hibernate no distingue entre una referencia de colección nula y una colección vacía."
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr "No debes tener que preocuparte demasiado por esto. Usa las colecciones persistentes de la misma forma en que usas colecciones de Java ordinarias. Sólo asegúrate que entiendes la semántica de las asociaciones bidireccionales (discutida luego)."
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr "Mapeos de colección"
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr "El elemento de mapeo de Hibernate usado para mapear una colección depende del tipo de la interface. Por ejemplom un elemento <literal><set></literal> se usa para mapear propiedades de tipo <literal>Set</literal>."
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr "Aparte de <literal><set></literal>, existen además los elementos de mapeo <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> y <literal><primitive-array></literal>. El elemento <literal><map></literal> es representativo:"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr "<literal>name</literal> el nombre de la propiedad de colección"
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr "<literal>table</literal> (opcional - por defecto al nombre de la propiedad) el nombre de la tabla de coleciión (no usado para asociaciones uno-a-muchos)"
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr "<literal>schema</literal> (opcional) el nombre de un esquema de tablas para sobrescribir el esquema declarado en el elemento raíz"
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr "<literal>lazy</literal> (opcional - por defecto a <literal>true</literal>) puede ser usado para deshabilitar la recuperación perezosa y especificar que la asociación es siempre recuperada tempranamente (no disponible para arrays)"
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr "<literal>inverse</literal> (opcional - por defecto a <literal>false</literal>) marca esta colección como el extremo \"inverso\" de una asociación bidireccional."
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr "<literal>cascade</literal> (opcional - por defecto a <literal>none</literal>) habilita operaciones en cascada a entidades hijas"
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr "<literal>sort</literal> (opcional) especifica una colección con ordenamiento <literal>natural</literal>, o una clase comparadora dada"
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr "<literal>order-by</literal> (opcional, sólo JDK1.4) especifica una columna de tabla (o columnas) que definen el orden de iteración del <literal>Map</literal>, <literal>Set</literal> o bag, junto a un <literal>asc</literal> o <literal>desc</literal> opcional."
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr "<literal>where</literal> (opcional) especifica una condición <literal>WHERE</literal> de SQL arbitrario para ser usada al recuperar o quitar la colección (útil si la colección debe contener sólo un subconjunto de los datos disponibles)"
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr "<literal>fetch</literal> (opcional, por defecto a <literal>select</literal>) Elige entre recuperación por unión externa (outer-join), recuperar por selección secuencial, y recuperación por subselección secuencial."
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr "<literal>batch-size</literal> (opcional, por defecto a <literal>1</literal>) especifica un \"tamaño de lote\" para la recuperar perezosamente instancias de esta colección."
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr "<literal>access</literal> (opcional - por defecto a <literal>property</literal>): La estrategia que debe usar Hibernate para acceder al valor de la propiedad."
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica que los cambios de estado de la colección resultan en incrementos de versión de la entidad dueña. (Para asociaciones uno a muchos, frecuentemente es razonable deshabilitar esta opción.)"
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr "Claves foráneas de collección"
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr "Las instancias de colección se distinguen en la base de datos por la clave foránea de la entidad que posee la colección. Se hace referencia a esta clave foránea como la <emphasis>columna clave de colección</emphasis> (o columnas) de la tabla de colección. La columna clave de la colección es mapeada por el elemento <literal><key></literal>."
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr "Puede haber una restricción de nulabilidad sobre la columna de clave foránea. Para la mayoría de colecciones, esto está implicado. Para asociaciones unidireccionales uno a muchos, la columna de clave foránea es nulable por defecto, de modo que podrías necesitar especificar <literal>not-null=\"true\"</literal>."
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr "La restricción de clave foránea puede usar <literal>ON DELETE CASCADE</literal>."
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr "Mira el capítulo anterior por una definición completa del elemento <literal><key></literal>."
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr "Elementos de collección"
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr "Las colecciones pueden contener casi cualquier tipo de Hibernate, incluyendo todos los tipos básicos, componentes, y por supuesto, referencias a otras entidades. Esta es una distinción importante: un objeto en una colección puede ser manejado con una semántica de \"valor\" (su ciclo de vida depende completamente del propietario de la colección) o podría ser una referencia a otra entidad, con su propio ciclo de vida. En el último caso, sólo el estado del \"enlace\" entre los dos objetos se considera mantenido por la colección."
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr "Se hace referencia al tipo contenido como el <emphasis>tipo de elemento de la colección</emphasis>. Los elementos de colección son mapeados por <literal><element></literal> o <literal><composite-element></literal>, o en el caso de referencias de entidades, con <literal><one-to-many></literal> o <literal><many-to-many></literal>. Las dos primeras mapean elementos con semántica de valor, los dos siguientes son usados para mapear asociaciones de entidades."
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr "Colecciones indexadas"
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr "Todos los mapeos de colección, excepto aquellos con semántica de set o bag, necesitan una <emphasis>columna índice</emphasis> en la tabla de colección, una columna que mapea a un índice de array, o índice de <literal>List</literal>, o clave de <literal>Map</literal>. El índice de un <literal>Map</literal> puede ser de cualquier tipo básico, mapeado con <literal><map-key></literal>, o puede ser una referencia de entidad, mapeada con <literal><map-key-many-to-many></literal>, o puede ser un tipo compuesto, mapeado con <literal><composite-map-key></literal>. El índice de un array o lista es siempre de tipo <literal>integer</literal> y se mapea usando el elemento <literal><list-index></literal>. La columna mapeada contiene enteros secuenciales (numerados desde cero, por defecto)."
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (requerido): El nombre de la columna que tiene los valores índice de la colección. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (opcional, por defecto a <literal>0</literal>): El valor de la columna índice que corresponde al primer elemento de la lista o array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (opcional): El nombre de la columna que tiene los valores índice de la colección. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (opcional): Una fórmula SQL usada para evaluar la clave del mapa. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (requerido): el tipo de las claves del mapa. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (opcional): El nombre de la columna clave foránea para los valores índice de la colección. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (opcional): Una fórmula SQL usada para evaluar la clave foránea de la clave del mapa. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (requerido): La clase de entidad usada como clave del mapa. </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr "Si tu tabla no tiene una columna índice, y deseas aún usar <literal>List</literal> como tipo de propiedad, debes mapear la propiedad como un <emphasis><bag></emphasis> de Hibernate. Un bag (bolsa) no retiene su orden al ser recuperado de la base de datos, pero puede ser ordenado o clasificado opcionalmente."
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr "Hay absolutamente un rango de mapeos que pueden ser generados para colecciones, cubriendo muchos modelos relacionales comunes. Te sugerimos que experimentes con la herramienta de generación de esquemas para obtener una idea de cómo varias declaraciones de mapeo se traducen a tablas de base de datos."
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr "Colecciones de valores y asociaciones muchos-a-muchos"
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr "Cualquier colección de valores o asociación muchos a muchos requiere una <emphasis>tabla de colección</emphasis> dedicada con una columna o columnas de clave foránea, <emphasis>columna de elemento de colección</emphasis> o columnas y posiblemente una columna o columnas índice."
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr "Para una colección de valores, usamos la etiqueta <literal><element></literal>."
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (opcional): El nombre de la columna que tiene los valores de los elementos de la colección. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (opcional): Una fórmula SQL usada para evaluar el elemento. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (requerido): El tipo del elemento de colección. </para> </callout> </calloutlist> </programlistingco> <para> Una <emphasis>asociación muchos-a-muchos</emphasis> se especifica usando el elemento <literal><many-to-many></literal>. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/!
> <area id=\"manytomany7\" coords=\"8 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (opcional): El nombre de la columna de clave foránea del elemento. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (opcional): Una fórmula SQL opcional usada para evaluar el valor de clave foránea del elemento. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (requerido): El nombre de la clase asociada. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (opcional - por defecto a <literal>join</literal>): habilita la recuperación por unión externa o selección secuencial para esta asociación. Este es un caso especial; para una recuperación completamente temprana (en un solo <literal>SELECT</literal>) de una entidad y sus relaciones muchos-a-muchos a otras entidades, deberías habilitar la re!
cuperación <literal>join</literal> no sólo de la colección misma, sino también con este atributo en el elemento anidado <literal><many-to-many></literal>. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (opcional): Habilita la generación DDL de una restricción de unicidad para la columna clave foránea. Esto hace la multiplicidad de la asociación efectivamente uno a muchos. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (opcional - por defecto a <literal>exception</literal>): Especifica cómo serán manejadas las claves foráneas que referencian filas perdidas: <literal>ignore</literal> tratará una fila perdida como una asociación nula. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (opcional): El nombre de entidad de la clase asociada, como una alternativa !
a <literal>class</literal>. </para> </callout> </calloutlist> </progra
mlistingco>"
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr "Algunos ejemplos, primero, un conjunto de cadenas:"
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr "Un bag conteniendo enteros (con un orden de iteración determinado por el atributo <literal>order-by</literal>):"
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr "Un array de entidades - en este caso, una asociación muchos a muchos:"
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr "Un mapa de índices de cadenas a fechas:"
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr "Una lista de componentes (discutidos en el próximo capítulo):"
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr "Asociaciones uno-a-muchos"
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr "Una <emphasis>asociación uno a muchos</emphasis> enlaza las tablas de dos clases por medio de una clave foránea, sin intervención de tabla de colección alguna. Este mapeo pierde cierta semántica de colecciones Java normales:"
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr "Una instancia de la clase entidad contenida no puede pertenecer a más de una instancia de la colección."
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr "Una instancia de la clase entidad contenida no puede aparecer en más de un valor del índice de colección."
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr "Una asociación de <literal>Product</literal> a <literal>Part</literal> requiere la existencia de una columna clave foránea y posiblemente una columna índice a la tabla <literal>Part</literal>. Una etiqueta <literal><one-to-many></literal> indica que ésta es una asociación uno a muchos."
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr "<literal>class</literal> (requerido): El nombre de la clase asociada."
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr "<literal>not-found</literal> (opcional - por defecto a <literal>exception</literal>): Especifica cómo serán manejados los identificadores en caché que referencien filas perdidas: <literal>ignore</literal> tratará una fila perdida como una asociación nula."
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>entity-name</literal> (opcional): El nombre de entidad de la clase asociada, como una alternativa a <literal>class</literal>."
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr "Observa que el elemento <literal><one-to-many></literal> no necesita declarar ninguna columna. Ni es necesario especificar el nombre de <literal>table</literal> en ningún sitio."
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr "<emphasis>Nota muy importante:</emphasis> Si la columna clave foránea de una asociación <literal><one-to-many></literal> es declarada <literal>NOT NULL</literal>, debes declarar el mapeo de <literal><key></literal> <literal>not-null=\"true\"</literal> o <emphasis>usar una asociación bidireccional</emphasis> con el mapeo de colección marcado <literal>inverse=\"true\"</literal>. Ver la discusión sobre asociaciones bidireccionales más adelante en este capítulo."
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr "Este ejemplo muestra un mapa de entidades <literal>Part</literal> por nombre (donde <literal>partName</literal> es una propiedad persistente de <literal>Part</literal>). Observa el uso de un índice basado en fórmula."
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr "Mapeos de colección avanzados"
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr "Colecciones ordenadas"
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr "Hibernate soporta colecciones implementando <literal>java.util.SortedMap</literal> y <literal>java.util.SortedSet</literal>. Debes especificar un comparador en el fichero de mapeo:"
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr "Los valores permitidos del atributo <literal>sort</literal> son <literal>unsorted</literal>, <literal>natural</literal> y el nombre de una clase que implemente <literal>java.util.Comparator</literal>."
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr "Las colecciones ordenadas realmente se comportan como <literal>java.util.TreeSet</literal> o <literal>java.util.TreeMap</literal>."
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr "Si quieres que la misma base de datos ordene los elementos de colección usa el atributo <literal>order-by</literal> de los mapeos <literal>set</literal>, <literal>bag</literal> o <literal>map</literal>. Esta solución está disponible sólo bajo el JDK 1.4 o superior (está implementado usando <literal>LinkedHashSet</literal> o <literal>LinkedHashMap</literal>). Esto realiza la ordenación en la consulta SQL, no en memoria."
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr "Observa que el valor del atributo <literal>order-by</literal> es una ordenación SQL, no una ordenación HQL!"
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr "Las asociaciones pueden incluso ser ordenadas por algún criterio arbitrario en tiempo de ejecución usando un <literal>filter()</literal> de colección."
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr "Asociaciones bidireccionales"
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr "Una <emphasis>asociación bidireccional</emphasis> permite la nevegación desde ambos \"extremos\" de la asociación. Son soportados dos tipos de asociación bidireccional:"
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr "uno-a-muchos"
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr "set o bag valorados en un extremo, monovaluados al otro"
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr "muchos-a-muchos"
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr "set o bag valorados a ambos extremos"
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr "Puedes especificar una asociación bidireccional muchos-a-muchos simplemente mapeando dos asociaciones muchos-a-muchos a la misma tabla de base de datos y declarando un extremo como <emphasis>inverse</emphasis> (cuál de ellos es tu elección, pero no puede ser una colección indexada)."
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr "He aquí un ejemplo de una asociación bidireccional muchos-a-muchos; cada categoría puede tener muchos ítems y cada ítem puede estar en muchas categorías:"
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>
+\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr "Los cambios hechos sólo al extremo inverso de la asociación <emphasis>no</emphasis> son persistidos. Esto significa que Hibernate tiene dos representaciones en memoria para cada asociación bidireccional, una enlaza de A a B y otra enlaza de B a A. Esto es más fácil de entender si piensas en el modelo de objetos de Java y cómo creamos una relación muchos-a-muchos en Java:"
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr "El lado no-inverso se usa para salvar la representación en memoria a la base de datos."
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr "Puedes definir una asociación bidireccional uno-a-muchos mapeando una asociación uno-a-muchos a la misma columna (o columnas) de tabla como una asociación muchos-a-uno y declarando el extremo multivaluado <literal>inverse=\"true\"</literal>."
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"eg.Child\">\n"
+ " <id name=\"id\" column=\"id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr "Mapear un extremo de una asociación con <literal>inverse=\"true\"</literal> no afecta la operación de cascadas; éstos son conceptos ortogonales!"
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr "Asociaciones bidireccionales con colecciones indexadas"
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr "Requiere especial consideración una asociación bidireccional donde un extremo esté representado como una <literal><list></literal> o <literal><map></literal>. Si hay una propiedad de la clase hija que mapee a la columna índice, no hay problema, podemos seguir usando <literal>inverse=\"true\"</literal> en el mapeo de la colección:"
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr "Pero, si no existe tal proiedad en la clase hija, no podemos pensar en la asociación como verdaderamente bidireccional (hay información en un extremo de la asociación que no está disponible en el otro extremo). En este caso, no podemos mapear la colección con <literal>inverse=\"true\"</literal>. En cambio, podríamos usar el siguiente mapeo:"
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr "Nota que, en este mapeo, el extremo de la asociación valuado en colección es responsable de las actualizaciones a la clave foránea."
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr "Asociaciones ternarias"
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr "Hay tres enfoques posibles para mapear una asociación ternaria. Una es usar un <literal>Map</literal> con una asociación como su índice:"
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr "Un segundo enfoque es simplemente remodelar la asociación como una clase de entidad. Este es el enfoque que usamos más comunmente."
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr "Una alternativa final es usar elementos compuestos, que discutiremos más adelante."
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr "Usando un <idbag>"
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr "Si has adoptado completamente nuestra visión de que las claves compuestas son una cosa mala y que las entidades deben tener identificadores sitéticos (claves delegadas), entonces podrías encontrar un poco raro que todas las asociaciones muchos a muchos y las colecciones de valores que hemos mostrado hasta ahora mapeen a tablas con claves compuestas! Ahora, este punto es discutible; una tabla de pura asociación no parece beneficiarse demasiado de una clave delegada (aunque sí <emphasis>podría</emphasis> una colección de valores compuestos). Sin embargo, Hibernate provee una funcionalidad que te permite mapear asociaciones muchos a muchos y colecciones de valores a una tabla con una clave delegada."
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr "El elemento <literal><idbag></literal> te permite mapear una <literal>List</literal> (o <literal>Collection</literal>) con semántica de bag."
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr "Como puedes ver, un <literal><idbag></literal> tiene un generador de id sintético, igual que una clase de entidad! Una clave delegada diferente se asigna a cada fila de la colección. Hibernate no provee ningún mecanismo para descubrir el valor de clave delegada de una fila en particular, sin embargo."
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr "Observa que el rendimiento de actualización de un <literal><idbag></literal> es <emphasis>mucho</emphasis> mejor que el de un <literal><bag></literal> regular! Hibernate puede localizar filas individuales eficientemente y actualizarlas o borrarlas individualmente, igual que si fuese una lista, mapa o conjunto."
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr "En la implementación actual, la estrategia de generación de identificador <literal>native</literal> no está soportada para identificadores de colecciones <literal><idbag></literal>."
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr "Ejemplos de colección"
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr "Las secciones previas son bastantes confusas. Así que miremos un ejemplo. Esta clase:"
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr "tiene una colección de instancias de <literal>Child</literal>. Si cada hijo tiene como mucho un padre, el mapeo más natural es una asociación uno-a-muchos:"
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Esto mapea a las siguientes definiciones de tablas:"
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr "Si el padre es <emphasis>requerido</emphasis>, usa una asociación bidireccional uno-a-muchos:"
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Observa la restricción <literal>NOT NULL</literal>:"
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr "Alternativamente, si absolutamente insistes que esta asociación debe ser unidireccional, puedes declarar la restricción <literal>NOT NULL</literal> en el mapeo de <literal><key></literal>:"
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "En la otra mano, si un hijo pudiera tener múltiples padres, sería apropiada una asociación muchos-a-muchos:"
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Definiciones de tabla:"
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr "Para más ejemplos y un paseo completo a través del mapeo de relaciones padre/hijo, ver <xref linkend=\"example-parentchild\"/>."
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr "Son posibles mapeos de asociación aún más complejos. Catalogaremos todas las posibilidades en el próximo capítulo."
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,532 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr "Mapeo de Componentes"
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr "La noción de un <emphasis>componente</emphasis> es reusada en muchos contextos diferentes, para propósitos diferentes, a través de Hibernate."
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr "Objetos dependientes"
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr "Un componente es un objeto contenido que es persistido como un tipo de valor, no una referencia de entidad. El término \"componente\" hace referencia a la noción orientada a objetos de composición (no a componentes a nivel de arquitectura). Por ejemplo, podrías modelar una persona como:"
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr "Ahora <literal>Name</literal> puede ser persistido como un componente de <literal>Person</literal>. Observa que <literal>Name</literal> define métodos getter y setter para sus propiedades persistentes, pero no necesita declarar ninguna interface ni propiedades identificadoras."
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr "Nuestro mapeo de Hibernate se vería así:"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid.hex\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:38
+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 "La tabla person tendría las columnas <literal>pid</literal>, <literal>birthday</literal>, <literal>initial</literal>, <literal>first</literal> y <literal>last</literal>."
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr "Como todos los tipos de valor, los componentes no soportan referencias compartidas. En otras palabras, dos personas pueden tener el mismo nombre, pero los dos objetos persona contendrían dos objetos nombre independientes, sólo \"iguales\" en valor. La semántica de valor nulo de un componente es <emphasis>ad hoc</emphasis>. Cuando se recargue el objeto contenedor, Hibernate asumirá que si todas las columnas del componente son nulas, el componente entero es nulo. Esto debe estar bien para la mayoría de propósitos."
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr "Las propiedades de un componentes pueden ser de cualquier tipo de Hibernate (colecciones, muchos-a-uno, asociaciones, otros componentes, etc). Los componentes anidados <emphasis>no</emphasis> deben ser considerados un uso exótico. Hibernate está concebido para soportar un modelo de objetos granularizado en fino."
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "El elemento <literal><component></literal> permite un subelemento <literal><parent></literal> que mapee una propiedad de la clase del componente como una referencia de regreso a la entidad contenedora."
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid.hex\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr "Colecciones de objetos dependientes"
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr "Las colecciones de componentes están soportadas (por ejemplo, un array de tipo <literal>Name</literal>). Declara tu colección de componentes remplazando la etiqueta <literal><element></literal> por una etiqueta <literal><composite-element></literal>."
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr "Nota: si defines un <literal>Set</literal> de elementos compuestos, es muy importante implementar <literal>equals()</literal> y <literal>hashCode()</literal> correctamente."
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr "Los elementos compuestos pueden contener componentes pero no colecciones. Si tu elemento compuesto contiene a su vez componentes, usa la etiqueta <literal><nested-composite-element></literal>. Este es un caso bastante exótico - una colección de componentes que a su vez tienen componentes. A esta altura debes estar preguntándote si una asociación uno-a-muchos es más apropiada. Intenta remodelar el elemento compuesto como una entidad - pero observa que aunque el modelo Java es el mismo, el modelo relacional y la semántica de persistencia siguen siendo ligeramente diferentes."
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr "Por favor observa que un mapeo de elemento compuesto no soporta propiedades nulables si estás usando un <literal><set></literal>. Hibernate tiene que usar cada columna para identificar un registro al borrar objetos (no hay una columna clave primaria separada en la tabla del elemento compuesto), lo que es imposible con valores nulos. Tienes que, o bien usar sólo propiedades no nulas en un elemento compuesto o elegir un <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> o <literal><idbag></literal>."
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 "Un caso especial de un elemento compuesto es un elemento compuesto con un elemento anidado <literal><many-to-one></literal>. Un mapeo como este te permite mapear columnas extra de una tabla de asociación muchos-a-muchos a la clase del elemento compuesto. La siguiente es una asociación muchos-a-muchos de <literal>Order</literal> a <literal>Item</literal> donde <literal>purchaseDate</literal>, <literal>price</literal> y <literal>quantity</literal> son propiedades de la asociación:"
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr "Por supuesto, no puede haber una referencia a la compra del otro lado para la navegación bidireccional de la asociación. Recuerda que los componentes son tipos de valor no permiten referencias compartidas. Una sola <literal>Purchase</literal> puede estar en el conjunto de una <literal>Order</literal>, pero no puede ser referenciada por el <literal>Item</literal> al mismo tiempo."
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr "Incluso son posibles las asociaciones ternarias (o cuaternarias, etc):"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr "Los elementos compuestos pueden aparecer en consultas usando la misma sintáxis que las asociaciones a otras entidades."
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr "Componentes como índices de Map"
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr "El elemento <literal><composite-map-key></literal> te permite mapear una clase componente como la clave de un <literal>Map</literal>. Asegúrate que sobrescribes <literal>hashCode()</literal> y <literal>equals()</literal> correctamente en la clase componente."
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr "Componentes como identificadores compuestos"
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr "Puedes usar un componente como un identidicador de una clase entidad. Tu clase componente debe satisfacer ciertos requerimientos:"
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr "Debe implementar <literal>java.io.Serializable</literal>."
+
+#: index.docbook:170
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr "Debe re-implementar <literal>equals()</literal> y <literal>hashCode()</literal>, consistentemente con la noción de base de datos de igualdad de clave compuesta."
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr "Nota: en Hibernat3, el segundo requerimiento no es absolutamente un requerimiento rígido de Hibernate. Pero de todas formas, házlo."
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr "No puedes usar un <literal>IdentifierGenerator</literal> para generar claves compuestas. La aplicación debe, en cambio, asignar sus propios identificadores."
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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 "Usa la etiqueta <literal><composite-id></literal> (con elementos anidados <literal><key-property></literal>) en lugar de la usual declaración <literal><id></literal>. Por ejemplo, la clase <literal>OrderLine</literal> tiene una clave primaria que depende de la clave primaria (compuesta) de <literal>Order</literal>."
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr "Ahora, cualquier clave foránea que referencie la tabla de <literal>OrderLine</literal> es también compuesta. Debes declarar esto en tus mapeos de otras clases. Una asociación a <literal>OrderLine</literal> sería mapeado así:"
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr "(Nota que la etiqueta <literal><column></literal> es una alternativa al atributo <literal>column</literal> en cualquier sitio.)"
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr "Una asociación <literal>muchos-a-muchos</literal> a <literal>OrderLine</literal> también usa la clave foránea compuesta:"
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr "La colección de <literal>OrderLine</literal>s en <literal>Order</literal> usaría:"
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr "(El elemento <literal><one-to-many></literal>, como es usual, no declara columnas.)"
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr "Si <literal>OrderLine</literal> posee una colección por sí misma, tiene también una clave foránea compuesta."
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr "Componentes dinámicos"
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr "Puedes incluso mapear una propiedad de tipo <literal>Map</literal>:"
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr "La semántica de un mapeo <literal><dynamic-component></literal> es ídentica a la de <literal><component></literal>. La ventaja de este tipo de mapeos es la habilidad para determinar las propiedades reales del bean en tiempo de despliegue, sólo con editar el documento de mapeo. La manipulación del documento de mapeo en tiempo de ejecución es también posible, usando un analizador DOM. Incluso mejor, puedes acceder (y cambiar) el metamodelo de tiempo de configuración de Hibernate por medio del objeto <literal>Configuration</literal>."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1598 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr "Configuración"
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr "Debido a que Hibernate está diseñado para operar en muchos entornos diferentes, hay un gran número de parámetros de configuración. Afortunadamente, la mayoría tiene valores por defecto sensibles e Hibernate se distribuye con un fichero <literal>hibernate.properties</literal> de ejemplo en <literal>etc/</literal> que muestra las diversas opciones. Tan sólo pon el fichero de ejemplo en tu classpath y personalízalo."
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr "Configuración programática"
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr "Una instancia de <literal>org.hibernate.cfg.Configuration</literal> representa un conjunto entero de mapeos de los tipos Java de una aplicación a una base de datos SQL. La <literal>Configuration</literal> es usada para construir una <literal>SessionFactory</literal> (inmutable). Los mapeos se compilan de varios ficheros de mapeo XML."
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr "Puedes obtener una instancia de <literal>Configuration</literal> instanciándola directamente y especificando documentos de mapeo XML. Si los ficheros de mapeo están en el classpath, usa <literal>addResource()</literal>:"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr "Una forma alternativa (a veces mejor) es especificar la clase mapeada, y dejar que Hibernate encuentre el documento de mapeo por ti:"
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr "Entonces Hibernate buscará ficheros de mapeo llamados <literal>/org/hibernate/auction/Item.hbm.xml</literal> y <literal>/org/hibernate/auction/Bid.hbm.xml</literal> en el classpath. Este enfoque elimina cualquier nombre de fichero en el código."
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr "Una <literal>Configuration</literal> también te permite especificar propiedades de configuración:"
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr "Esta no es la única forma de pasar propiedades de configuración a Hibernate. La diversas opciones incluyen:"
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr "Pasar una instancia de <literal>java.util.Properties</literal> a <literal>Configuration.setProperties()</literal>."
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr "Colocar <literal>hibernate.properties</literal> en un directorio raíz del classpath."
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr "Establecer propiedades <literal>System</literal> usando <literal>java -Dproperty=value</literal>."
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr "Incluir elementos <literal><property></literal> en <literal>hibernate.cfg.xml</literal> (discutido luego)."
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr "<literal>hibernate.properties</literal> es el enfoque más fácil si quieres comenzar rápido."
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr "La <literal>Configuration</literal> está concebida como un objeto de tiempo de arranque, para ser descartado una vez que una <literal>SessionFactory</literal> es creada."
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr "Obteniendo una SessionFactory"
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr "Cuando todos los mapeos han sido parseados por la <literal>Configuration</literal>, la aplicación debe obtener una fábrica de instancias de <literal>Session</literal>. Esta fábrica está concebida para ser compartida por todas las hebras de aplicación:"
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr "Hibernate permite que tu aplicación instancie más de una <literal>SessionFactory</literal>. Esto es útil si estás usando más de una base de datos."
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr "Conexiones JDBC"
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr "Usualmente, quieres que la <literal>SessionFactory</literal> cree y almacene en pool conexiones JDBC para ti. Si adoptas este enfoque, abrir una <literal>Session</literal> es tan simple como:"
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr "En cuanto hagas algo que requiera acceso a la base de datos, se obtendrá una conexión JDBC del pool."
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr "Para que esto funcione, necesitamos pasar algunas propiedades de conexión JDBC a Hibernate. Todos los nombres de propiedades y su semántica están definidas en la clase <literal>org.hibernate.cfg.Environment</literal>. Describiremos ahora las configuraciones más importantes para la conexión JDBC."
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr "Hibernate obtendrá (y tendrá en pool) conexiones usando <literal>java.sql.DriverManager</literal> si configuras las siguientes propiedades:"
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr "Propiedades JDBC de Hibernate"
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr "Nombre de propiedad"
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr "Propósito"
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr "clase del driver jdbc"
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr "URL de jdbc"
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:179
+msgid "database user"
+msgstr "usuario de base de datos"
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:187
+msgid "database user password"
+msgstr "contraseña del usuario de base de datos"
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr "hibernate.connection.pool_size"
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr "número máximo de conexiones manejadas por pooling"
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr "El algoritmo de pooling de conexiones propio de Hibernate es sin embargo algo rudimentario. Está concebido para ayudarte a comenzar y <emphasis>no está concebido para usar en un sistema de producción</emphasis> ni siquiera para pruebas de rendimiento. Debes usar un pool de terceros para un mejor rendimiento y estabilidad. Sólo remplaza la propiedad <literal>hibernate.connection.pool_size</literal> con configuraciones específicas del pool de conexiones. Esto desactivará el pool interno de Hibernate. Por ejemplo, podrías querer usar C3P0."
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr "C3P0 es un pool de conexiones JDBC de código abierto distribuido junto a Hibernate en el directorio <literal>lib</literal>. Hibernate usará su <literal>C3P0ConnectionProvider</literal> para pooling de conexiones si estableces propiedades <literal>hibernate.c3p0.*</literal>. Si quieres usar Proxool refiérete al <literal>hibernate.properties</literal> empaquetado y al sitio web de Hibernate para más información."
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr "Aquí hay un fichero <literal>hibernate.properties</literal> de ejemplo para C3P0:"
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr "Para su uso en un servidor de aplicaciones, casi siempre debes configurar Hibernate para que obtenga conexiones de un <literal>Datasource</literal> del servidor de aplicaciones registrado en JNDI. Necesitarás establecer al menos una de las siguientes propiedades:"
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr "Propiedades de Datasource de Hibernate"
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr "hibernate.connection.datasource"
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr "nombre del datasource JNDI"
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr "hibernate.jndi.url"
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr "<emphasis>URL del provedor JNDI</emphasis> (optional)"
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr "hibernate.jndi.class"
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr "<emphasis>clase de la <literal>InitialContextFactory</literal> de JNDI</emphasis> (opcional)"
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr "<emphasis>usuario de base de datos</emphasis> (opcional)"
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr "<emphasis>contraseña del usuario de base de datos</emphasis> (opcional)"
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr "He aquí un fichero <literal>hibernate.properties</literal> de ejemplo para un un datasource JNDI provisto por un servidor de aplicaciones."
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr "Las conexiones JDBC obtenidas de un datasource JNDI participarán automáticamente en las transacciones del servidor de aplicaciones manejadas por contenedor."
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr "Pueden darse propiedades de conexión arbitrarias anteponiendo \"<literal>hibernate.connnection</literal>\" al nombre de propiedad. Por ejemplo, puedes especificar un <literal>charSet</literal> usando <literal>hibernate.connection.charSet</literal>."
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr "Puedes definir tu propia estrategia de plugin para obtener conexiones JDBC implementando la interface <literal>org.hibernate.connection.ConnectionProvider</literal>. Puedes seleccionar una implementación personalizada estableciendo <literal>hibernate.connection.provider_class</literal>."
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr "Parámetros de configuración opcionales"
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr "Hay un número de otras propiedades que controlan el comportamiento de Hibernate en tiempo de ejecución. Todas son opcionales y tienen valores por defecto razonables."
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr "<emphasis>Advertencia: algunas de estas propiedades son de \"nivel-de-sistema\" solamente.</emphasis>. Las propiedades a nivel de sistema sólo pueden ser establecidas por medio de <literal>java -Dproperty=value</literal> o <literal>hibernate.properties</literal>. <emphasis>No</emphasis> pueden establecerse por medio de las otras técnicas arriba descritas."
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr "Propiedades de Configuración de Hibernate"
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr "El nombre de clase de un <literal>Dialect</literal> de Hibernate que permite a Hibernate generar SQL optimizado para una base de datos relacional en particular."
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>full.classname.of.Dialect</literal>"
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr "hibernate.show_sql"
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr "Escribe todas las sentencias SQL a la consola."
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr "hibernate.default_schema"
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr "Cualifica, en el SQL generado, los nombres de tabla sin cualificar con el esquema/tablespace dado."
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr "hibernate.default_catalog"
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr "Cualifica, en el SQL generado, los nombres de tabla sin cualificar con el catálogo dado."
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>CATALOG_NAME</literal>"
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr "hibernate.session_factory_name"
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr "La <literal>SessionFactory</literal> será ligada a este nombre en JNDI automáticamente después de ser creada."
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>jndi/composite/name</literal>"
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr "hibernate.max_fetch_depth"
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr "Establece una \"profundidad\" máxima del árbol de recuperación por outer join para asociaciones de un extremo solo (uno-a-uno, muchos-a-uno). Un <literal>0</literal> deshabilita la recuperación por outer join por defecto."
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> valores recomendados entre <literal>0</literal> y <literal>3</literal>"
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr "hibernate.default_batch_fetch_size"
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr "Establece un tamaño por defecto para la recuperación en lote de asociaciones de Hibernate."
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> valores recomendados <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr "hibernate.default_entity_mode"
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr "Establece un modo por defecto de representación de entidades para todas las sesiones abiertas por esta <literal>SessionFactory</literal>"
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr "hibernate.order_updates"
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr "Fuerza a Hibernate a ordenar las actualizaciones SQL por el valor de la clave primaria de los items a actualizar. Esto resultará en menos bloqueos muertos de transacción en sistemas altamente concurrentes."
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr "hibernate.generate_statistics"
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr "De habilitarse, Hibernate colectará estadísticas útiles para la afinación de rendimiento."
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr "hibernate.use_identifer_rollback"
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr "De habilitarse, las propiedades identificadoras generadas serán reseteadas a valores por defecto cuando los objetos sean borrados."
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr "hibernate.use_sql_comments"
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr "De activarse, Hibernate generará comentarios dentro del SQL, para una más fácil depuración, por defecto a <literal>false</literal>."
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr "Propiedades de JDBC y Conexiones de Hibernate"
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr "Nombre de propiedad"
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr "hibernate.jdbc.fetch_size"
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr "Un valor distinto de cero habilita el uso de actualizaciones en lote de JDBC2 por Hibernate."
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> valores recomendados entre <literal>5</literal> y <literal>30</literal>"
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr "hibernate.jdbc.batch_versioned_data"
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr "Establece esta propiedad a <literal>true</literal> si tu driver JDBC devuelve cuentas correctas de filas desde <literal>executeBatch()</literal> (usualmente es seguro activar esta opción). Hibernate usará DML en lote para versionar automáticamente los datos. Por defecto a <literal>false</literal>."
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr "hibernate.jdbc.factory_class"
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr "Selecciona un <literal>Batcher</literal> personalizado. La mayoría de las aplicaciones no necesitarán esta propiedad de configuración."
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr "hibernate.jdbc.use_scrollable_resultset"
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr "Habilita el uso de resultados scrollables de JDBC2 por Hibernate. Esta propiedad sólo es necesaria cuando se usan conexiones JDBC provistas por el usuario, en caso contrario Hibernate usa los metadatos de conexión."
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr "hibernate.jdbc.use_streams_for_binary"
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr "Usa flujos (streams) al escribir/leer tipos <literal>binary</literal> o <literal>serializable</literal> a/desde JDBC (propiedad a nivel de sistema)."
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr "hibernate.jdbc.use_get_generated_keys"
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr "Habilita el uso de <literal>PreparedStatement.getGeneratedKeys()</literal> de JDBC3 para traer claves generadas nativamente después de insertar. Requiere un driver JDBC3+ y un JRE1.4+. Establécela a false si tu driver tiene problemas con los generadores de identificador de Hibernate. Por defecto, se intenta determinar las capacidades del driver usando los metadatos de conexión."
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr "hibernate.connection.provider_class"
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr "EL nombre de clase de un <literal>ConnectionProvider</literal> personalizado que provea conexiones JDBC a Hibernate."
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr "hibernate.connection.isolation"
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr "Establece el nivel de aislamiento de transacción JDBC. Comprueba <literal>java.sql.Connection</literal> para valores significativos pero observa que la mayoría de las bases de datos no soportan todos los niveles de aislamiento."
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr "hibernate.connection.autocommit"
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr "Habilita compromiso automático (autocommit) para las conexiones JDBC en pool (no recomendado)."
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr "hibernate.connection.release_mode"
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr "Especifica cuándo Hibernate debe liberar las conexiones JDBC. Por defecto, una conexión JDBC es retenida hasta que la sesión es cerrada explícitamente o desconectada. Para un datasource JTA del servidor de aplicaciones, debes usar <literal>after_statement</literal> para liberar agresivamente las conexiones después de cada llamada JDBC. Para una conexión no JTA, frecuentemente tiene sentido liberar la conexión al final de cada transacción, usando <literal>after_transaction</literal>. <literal>auto</literal> eligirá <literal>after_statement</literal> para las estrategias JTA o CMT de transacción y <literal>after_transaction</literal> para la estrategia JDBC de transacción."
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr "hibernate.connection.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr "Pasa la propiedad JDBC <literal>propertyName</literal> a <literal>DriverManager.getConnection()</literal>."
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr "hibernate.jndi.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr "Pasa la propiedad <literal>propertyName</literal> a <literal>InitialContextFactory</literal> de JNDI."
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr "Propiedades de Caché de Hibernate"
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr "Nombre de propiedad"
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr "Propósito"
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr "hibernate.cache.provider_class"
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr "El nombre de clase de un <literal>CacheProvider</literal> personalizado."
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr "Optimiza la operación del caché de segundo nivel para minimizar escrituras, al costo de lecturas más frecuentes. Esto es más útil para cachés en cluster y, en Hibernate3, está habilitado por defecto para implementaciones de caché en cluster."
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr "hibernate.cache.use_query_cache"
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr "Habilita el caché de lectura, consultas individuales todavía tienen que ponerse cachables."
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr "Puede ser usado para deshabilitar completamente el caché de segundo nivel, que está habilitado por defecto para clases que especifican un mapeo <literal><cache></literal>."
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr "El nombre de clase de una interface <literal>QueryCache</literal> personalizada, por defecto al <literal>StandardQueryCache</literal> prefabricado."
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>classname.of.QueryCache</literal>"
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr "Un prefijo a usar para los nombres de región del caché de segundo nivel."
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>prefix</literal>"
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr "hibernate.cache.use_structured_entries"
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr "Fuerza a Hibernate a almacenar los datos en el caché de segundo nivel en un formato más amigable al humano."
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr "Propiedades de Transacción de Hibernate"
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr "Nombre de propiedad"
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr "Propósito"
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr "El nombre de clase de un <literal>TransactionFactory</literal> a usar con la API de <literal>Transaction</literal> de Hibernate (por defectoa <literal>JDBCTransactionFactory</literal>)."
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr "Un nombre JNDI usado por <literal>JTATransactionFactory</literal> para obtener la <literal>UserTransaction</literal> JTA del servidor de aplicaciones."
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>jndi/composite/name</literal>"
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr "hibernate.transaction.manager_lookup_class"
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr "El nombre de clase de un <literal>TransactionManagerLookup</literal> requerido cuando el chaché a nivel de JVM está habilitado o cuando se usa un generador alto/bajo en un entorno JTA."
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr "De habilitarse, la sesión se limpiará (flushed) automáticamente durante la fase previa a la compleción de la transacción. (Muy útil cuando se usa Hibernate con CMT)."
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr "hibernate.transaction.auto_close_session"
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr "De habilitarse, la sesión será cerrada automáticamente durante la fase posterior a la compleción de la transacción. (Muy útil cuando se usa Hibernate con CMT)."
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr "Nombre de propiedad"
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "Propósito"
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr "Elige la implementación de parser HQL."
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr "Mapeos de símbolos en consultas Hibernate a símbolos SQL. (los símbolos puedem ser nombres de función o literales, por ejemplo)."
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr "hibernate.hbm2ddl.auto"
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr "Exporta automáticamente DDL de esquema cuando al crear la <literal>SessionFactory</literal>. Con <literal>create-drop</literal>, el esquema de base de datos será desechado cuando la <literal>SessionFactory</literal> se cierre explícitamente."
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr "hibernate.cglib.use_reflection_optimizer"
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr "Habilita el uso de CGLIB en vez de refleccón en tiempo de ejecución (propiedad a nivel de sistema). La reflección a veces puede ser útil ante la aparición de problemas. Observa que Hibernate siempre requiere CGLIB incluso si desactivas el optimizador. No puedes establecer esta propiedad en <literal>hibernate.cfg.xml</literal>."
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr "<emphasis role=\"strong\">ej.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr "SQL Dialects"
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr "Dialectos SQL de Hibernate(<literal>hibernate.dialect</literal>)"
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr "RDBMS"
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr "Dialecto"
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr "<entry>DB2</entry>"
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr "DB2 AS/400"
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr "org.hibernate.dialect.DB2400Dialect"
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr "DB2 OS390"
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr "org.hibernate.dialect.DB2390Dialect"
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr "PostgreSQL"
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr "org.hibernate.dialect.PostgreSQLDialect"
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr "MySQL"
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr "org.hibernate.dialect.MySQLDialect"
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr "MySQL con InnoDB"
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr "org.hibernate.dialect.MySQLInnoDBDialect"
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr "MySQL con MyISAM"
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr "org.hibernate.dialect.MySQLMyISAMDialect"
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr "Oracle (cualquier versión)"
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr "org.hibernate.dialect.OracleDialect"
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr "Oracle 9i/10g"
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr "org.hibernate.dialect.Oracle9Dialect"
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr "Sybase"
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr "org.hibernate.dialect.SybaseDialect"
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr "Sybase Anywhere"
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr "org.hibernate.dialect.SybaseAnywhereDialect"
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr "Microsoft SQL Server"
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr "org.hibernate.dialect.SQLServerDialect"
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr "SAP DB"
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr "org.hibernate.dialect.SAPDBDialect"
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr "Informix"
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr "org.hibernate.dialect.InformixDialect"
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr "HypersonicSQL"
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr "org.hibernate.dialect.HSQLDialect"
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr "Ingres"
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr "org.hibernate.dialect.IngresDialect"
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr "Progress"
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr "org.hibernate.dialect.ProgressDialect"
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr "Mckoi SQL"
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr "org.hibernate.dialect.MckoiDialect"
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr "Interbase"
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr "org.hibernate.dialect.InterbaseDialect"
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr "Pointbase"
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr "org.hibernate.dialect.PointbaseDialect"
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr "FrontBase"
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr "org.hibernate.dialect.FrontbaseDialect"
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr "Firebird"
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr "org.hibernate.dialect.FirebirdDialect"
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr "Recuperación por Unión Externa (Outer Join Fetching)"
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr "Si tu base de datos soporta uniones externas del estilo ANSI, Oracle o Sybase, la <emphasis>recuperación por unión externa</emphasis> aumentará frecuentemente el rendimiento limitando el número de llamadas a la base de datos (al costo de más trabajo posiblemente realizado por la base de datos misma). La recuperación por unión externa permite que un grafo completo de objetos conectados por asociaciones muchos-a-uno, uno-a-muchos, muchos-a-muchos y uno-a-uno sea traído en una sola <literal>SELECT</literal> SQL."
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr "La recuperación por unión externa puede ser deshabilitada <emphasis>globalmente</emphasis> estableciendo la propiedad <literal>hibernate.max_fetch_depth</literal> a <literal>0</literal>. Un valor de <literal>1</literal> o mayor habilita la recuperación por unión externa para asociaciones uno-a-uno y muchos-a-uno que hayan sido mapeadas con <literal>fetch=\"join\"</literal>."
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr "Ver <xref linkend=\"performance-fetching\"/> para más información."
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr "Flujos Binarios"
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr "Oracle limita el tamaño de arrays de <literal>byte</literal> que puedan ser pasados a/desde su driver JDBC. Si deseas usar instancias grandes de tipo <literal>binary</literal> o <literal>serializable</literal>, debes habilitar <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>Esta es una propiedad a nivel de sistema solamente.</emphasis>"
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr "Caché de segundo nivel y de lectura"
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr "Las propiedades prefijadas por <literal>hibernate.cache</literal> te permiten usar un sistema de caché de segundo nivel en el ámbito de un proceso o cluster con Hibernate. Ver <xref linkend=\"performance-cache\"/> para más detalles."
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr "Sustitución de Lenguaje de Consulta"
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr "Puedes definir nuevos símbolos de consulta de Hibernate usando <literal>hibernate.query.substitutions</literal>. Por ejemplo:"
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "hibernate.query.substitutions true=1, false=0"
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr "causaría que los símbolos <literal>true</literal> y <literal>false</literal> sean traducidos a literales enteros en el SQL generado."
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr "hibernate.query.substitutions toLowercase=LOWER"
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr "te permitiría renombrar la función <literal>LOWER</literal> de SQL."
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr "Hibernate statistics"
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr "Si habilitas <literal>hibernate.generate_statistics</literal>, Hibernate expondrá un número de métricas que son útiles al afinar un sistema en ejecución vía <literal>SessionFactory.getStatistics()</literal>. Hibernate puede incluso ser configurado para exponer estas estadísticas vía JMX. Lee el Javadoc de las interfaces en <literal>org.hibernate.stats</literal> para más información."
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr "Registros de mensajes (Logging)"
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr "Hibernate registra varios eventos usando commons-logging de Apache."
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr "El servicio de commons-logging saldrá directamente ya sea a Log4J (si incluyes <literal>log4j.jar</literal> in your classpath) o JDK1.4 logging (al ejecutar bajo JDK1.4 o superior). Puedes descargar Log4J desde <literal>http://logging.apache.org</literal>. Para usar Log4J necesitarás colocar un fichero <literal>log4j.properties</literal> en tu classpath. Un fichero de propiedades de ejemplo se distribuye con Hibernate en el directorio <literal>src/</literal>."
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr "Recomendamos fuertemente que te familiarices con los registros de mensajes de Hibernate. Se ha puesto un gran trabajo en hacer los registros de Hibernate tan detallados como se puede, sin hacerlos ilegibles. Es un dispositivo esencial en la resolución de problemas. Las categorías de registro más interesantes son las siguientes:"
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr "Categorías de Registro de Hibernate"
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr "Categoría"
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr "Función"
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr "org.hibernate.SQL"
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr "Registra todas las sentencias DML de SQL a medida que se ejecutan"
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr "org.hibernate.type"
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr "Registra todos los parámetros JDBC"
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr "org.hibernate.tool.hbm2ddl"
+
+#: index.docbook:1219
+msgid "Category"
+msgstr "Registra todas las sentencias DDL de SQL a medida que se ejecutan"
+
+#: index.docbook:1220
+msgid "Function"
+msgstr "org.hibernate.pretty"
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr "Registra el estado de todas las entidades (máximo de 20 entidades) asociadas con la sesión en tiempo de limpieza (flush)"
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr "org.hibernate.cache"
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr "Registra toda la actividad del caché de segundo nivel"
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr "org.hibernate.transaction"
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr "Registra la actividad relacionada con la transacción"
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr "org.hibernate.jdbc"
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr "Registra toda adquisición de recursos JDBC"
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr "org.hibernate.hql.ast"
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr "Regista los ASTs de HQL y SQL, así como otra información sobre análisis de consultas."
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr "org.hibernate.secure"
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr "Registra todas las peticiones de autorización JAAS"
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr "org.hibernate"
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr "Registra todo (mucha información, pero muy útil para la resolución de problemas)"
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr "Al desarrollar aplicacinoes con Hibernate, casi siempre debes trabajar con <literal>debug</literal> habilitado para la categoría <literal>org.hibernate.SQL</literal> o, alternativamente, la propiedad <literal>hibernate.show_sql</literal> habilitada."
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr "Implementando una <literal>NamingStrategy</literal>"
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr "La interface <literal>org.hibernate.cfg.NamingStrategy</literal> te permite especificar un \"estándar de nombrado\" para objetos de la base de datos y elementos de esquema."
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr "Puedes proveer reglas para generar automáticamente identificadores de base de datos a partir de identificadores JDBC o para procesar nombres \"lógicos\" de columnas y tablas dados en el fichero de mapeo en nombres \"físicos\" de columnas y tablas. Esta funcionalidad ayuda a reducir la verborragia del documento de mapeo, eliminando ruido repetitivo (prefijos <literal>TBL_</literal>, por ejemplo). La estrategia por defecto usada por Hibernate mínima en absoluto."
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr "Puedes especificar una estrategia diferente llamando a <literal>Configuration.setNamingStrategy()</literal> antes de agregar los mapeos:"
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> es una estrategia prefabricada que puede ser un punto de partida útil para algunas aplicaciones."
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr "Fichero de configuración XML"
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr "Un enfoque alternativo de configuración es especificar una configuración completa en un fichero llamado <literal>hibernate.cfg.xml</literal>. Este fichero puede ser usado como un remplazo del fichero <literal>hibernate.properties</literal> o, si ambos están presentes, para sobrescribir propiedades."
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr "El fichero de configuración XML se espera por defecto en la raíz o tu <literal>CLASSPATH</literal>. He aquí un ejemplo:"
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr "Como puedes ver, la ventaja de este enfoque es la externalización de los nombres de los fichero de mapeo a configuración. El <literal>hibernate.cfg.xml</literal> es también más conveniente una vez que hayas afinado el caché de Hibernate. Observa que elección tuya usar ya sea <literal>hibernate.properties</literal> o <literal>hibernate.cfg.xml</literal>, ambos son equivalentes, excepto por los beneficios de usar la sintaxis XML arriba mencionados."
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr "Con la configuración XML, arrancar Hibernate es tan simple como"
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr "Puedes tomar un fichero XML diferente usando"
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr "Integració con Servidores de Aplicaciones J2EE"
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr "Hibernate tiene los siguientes puntos de integración con la infraestructura J2EE:"
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr "<emphasis>Datasources manejados por contenedor</emphasis>: Hibernate puede usar conexiones JDBC manejadas por el contenedor y provistas a través de JNDI. Usualmente, un <literal>TransactionManager</literal> compatible con JTA y un <literal>ResourceManager</literal> cuidan del manejo de transacciones (CMT), esp. manejo de transacciones distribuídas a través de varios datasources. Puedes también, por supuesto, demarcar los límites de las transacciones programáticamente (BMT) o podrías querer usar para esto la API opcional de <literal>Transaction</literal> de Hibernate para mantener tu código portable."
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr "<emphasis>Ligamento Automático JNDI</emphasis>: Hibernate puede ligar sus <literal>SessionFactory</literal> a JNDI después del arranque."
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr "<emphasis>Ligamento de Sesión JTA:</emphasis> La <literal>Session</literal> de Hibernate puede ser ligada automáticamente al ámbito de transacciones JTA si usas EJBs. Simplemente busca la <literal>SessionFactory</literal> de JNDI y obtén la <literal>Session</literal> actual. Deja que Hibernate cuide de limpiar y cerrar la <literal>Session</literal> cuando se complete tu transacción JTA. La demarcación de transacción es declarativa, en descriptores de despliegue de EJB."
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr "<emphasis>Despliegue JMX:</emphasis> Si tienes un servidor de aplicaciones capaz de JMX (por ejemplo, JBoss AS), puedes optar por desplegar Hibernate como un MBean manejado. Esto te ahorra el código de una línea de arranque para construir tu <literal>SessionFactory</literal> desde una <literal>Configuration</literal>. El contenedor arrancará tu <literal>HibernateService</literal>, e idealmente también cuidará de las dependencias entre servicios (El datasource debe estar disponible antes que arranque Hibernate, etc)."
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr "Dependiendo de tu entorno, podrías tener que establecer la opción de configuración <literal>hibernate.connection.aggressive_release</literal> a true si tu servidor de aplicaciones muestra excepciones \"connection containment\"."
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr "Configuración de la estrategia de transacción"
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr "La API de <literal>Session</literal> de Hibernate es independiente de cualquier demarcación de transacción en tu arquitectura. Si dejas que Hibernate use JDBC directamente, a través de un pool de conexiones. puedes comenzar y acabar tus transacciones llamando la API de JDBC. Si ejecutas en un servidor de aplicaciones J2EE, podréas querer usar transacciones manejadas por bean y llamar la API de JTA y <literal>UserTransaction</literal> cuando sea necesario."
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr "Para mantener tu código portable entre estos dos (y otros) entornos recomendamos la API de <literal>Transaction</literal> de Hibernate, que envuelve y oculta el sistema subyacente. Tienes que especificar una clase fábrica para las instancias de <literal>Transaction</literal> estableciendo la propiedad de configuración <literal>hibernate.transaction.factory_class</literal> de Hibernate."
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr "Hay tres elecciones estándar (prefabricadas):"
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr "org.hibernate.transaction.JDBCTransactionFactory"
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr "delega a transacciones de base de datos (JDBC) (por defecto)"
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr "org.hibernate.transaction.JTATransactionFactory"
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr "delega a transacciones manejadas por contenedor si una transacción existente estó por debajo en este contexto (ej. método de un bean de sesión EJB), en otro caso una nueva transacción es comenzada y se usan transacciones manejadas por bean."
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr "org.hibernate.transaction.CMTTransactionFactory"
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr "delega a transacciones JTA manejadas por contenedor"
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr "Puedes definir también tus propias estrategias de transacción (para un servicio de transacción CORBA, por ejemplo)."
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr "Algunas funcionalidades en Hibernate (ej, el caché de segundo nivel, ligamento automático de JTA y Session, etc.) requieren acceso al <literal>TransactionManager</literal> de JTA en un entorno manejado. En un servidor de aplicaciones tienes que especificar cómo Hibernate debe obtener una referencia al <literal>TransactionManager</literal>, pues J2EE no estandariza un solo mecanismo:"
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr "TransactionManagers de JTA"
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr "Transaction Factory"
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr "Servidor de Aplicaciones"
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr "org.hibernate.transaction.JBossTransactionManagerLookup"
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr "JBoss"
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr "Weblogic"
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr "WebSphere"
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr "WebSphere 6"
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr "org.hibernate.transaction.OrionTransactionManagerLookup"
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr "Orion"
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr "org.hibernate.transaction.ResinTransactionManagerLookup"
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr "Resin"
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr "org.hibernate.transaction.JOTMTransactionManagerLookup"
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr "JOTM"
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr "org.hibernate.transaction.JOnASTransactionManagerLookup"
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr "JOnAS"
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr "org.hibernate.transaction.JRun4TransactionManagerLookup"
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr "JRun4"
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr "org.hibernate.transaction.BESTransactionManagerLookup"
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr "Borland ES"
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr "<literal>SessionFactory</literal> ligada a JNDI"
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr "Una <literal>SessionFactory</literal> de Hibernate ligada a JNDI puede simplificar la obtención de la fábrica y la creación de nuevas <literal>Session</literal>s. Observa que esto no está relacionado a un <literal>Datasource</literal> ligado a JNDI, simplemente ambos usan el mismo registro!"
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr "Si deseas tener la <literal>SessionFactory</literal> ligada a un espacio de nombres de JNDI, especifica un nombre (ej. <literal>java:hibernate/SessionFactory</literal>) usando la propiedad <literal>hibernate.session_factory_name</literal>. Si esta propiedad es omitida, la <literal>SessionFactory</literal> no será ligada a JNDI (Esto es especialmente útil en entornos con una implementació JNDI de sólo lectura por defecto, ej. Tomcat.)"
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr "Al ligar la <literal>SessionFactory</literal> a JNDI, Hibernate usará los valores de <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> para instanciar un contexto inicial. Si étos no se especifican, se usará el <literal>InitialContext</literal> por defecto."
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr "Hibernate colocará automáticamente la <literal>SessionFactory</literal> en JNDI después que llames a <literal>cfg.buildSessionFactory()</literal>. Esto significa que tendrás al menos esta llamada en algún código de arranque (o clase de utilidad) en tu aplicación, a menos qie uses el despliegue JMX con el <literal>HibernateService</literal> (discutido luego)."
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr "Si usas una <literal>SessionFactory</literal> de JNDI, un EJB o cualquier otra clase puede obtener la <literal>SessionFactory</literal> usando una búsqueda JNDI. Observa que esta configuración no es necesaria si usas la clase de ayuda <literal>HibernateUtil</literal> introducida en el capítulo uno, que actúa como un registro Singleton. Sin embargo, <literal>HibernateUtil</literal> es más común en un entorno no manejado."
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr "Ligado automático de JTA y Session"
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr "Para entornos no manejados hemos sugerido <literal>HibernateUtil</literal> con una <literal>SessionFactory</literal> estática, y administración de la <literal>Session</literal> de Hibernate. Este enfoque no es fácil de usar en un entorno EJB, al poder ejecutarse muchos EJBs dentro de la misma transacción pero no en la misma hebra. Recomendados que ligues la <literal>SessionFactory</literal> a JNDI en un entorno manejado."
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr "En vez de rodar tu propia utilidad de <literal>ThreadLocal</literal>, usa el método <literal>getCurrentSession()</literal> en la <literal>SessionFactory</literal> para obtener una <literal>Session</literal> de Hibernate. Si no hubiese una <literal>Session</literal> de Hibernate en la transacción JTA actual, se arrancará y asignará una. Ambas opciones de configuración <literal>hibernate.transaction.flush_before_completion</literal> y <literal>hibernate.transaction.auto_close_session</literal>, serán establecidas automáticamente para cada <literal>Session</literal> que obtengas con <literal>getCurrentSession()</literal>, de modo que éstas serán limpiadas (flushed) y cerradas automáticamente cuando el contenedor complete las transacciones JTA."
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr "Si tu, por ejemplo, usas el patrón de diseño DAO para escribir tu capa de persistencia, todos los DAO's buscan la <literal>SessionFactory</literal> cuando se necesite y abren la sesión \"actual\". No hay necesidad de pasar las instancias de <literal>SessionFactory</literal> o <literal>Session</literal> alrededor entre el código de control y el código DAO."
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr "Despliegue JMX"
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr "La línea <literal>cfg.buildSessionFactory()</literal> todavía tiene que ser ejecutada en algun sitio para obtener una <literal>SessionFactory</literal> en JNDI. Puedes hacer esto bien en un bloque inicializador <literal>static</literal> (como aquel en <literal>HibernateUtil</literal>) o bien despliegas Hibernate como un <emphasis>servicio manejado</emphasis>."
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr "Hibernate se distribuye con <literal>org.hibernate.jmx.HibernateService</literal> para despliegue en un servidor de aplicaciones con capacidades JMX, como JBoss AS. El despliegue y la configuracón reales son específicos del vendedor. He aquí un <literal>jboss-service.xml</literal> de ejemplo para JBoss 4.0.x:"
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr "Este fichero es desplegado en un directorio llamado <literal>META-INF</literal> y empaquetado en un fichero JAR con la extensión <literal>.sar</literal> (fichero de servicio). También necesitas empaquetar Hibernate, sus bibliotecas de terceros requeridas, tus clases persistentes compiladas, así como tus ficheros de mapeo en el mismo fichero. Tus beans de empresa (usualmente beans de sesión) pueden ser mantenidos en su propio fichero JAR, pero debes incluir este fichero EJB JAR en el fichero de servicio principal para obtener una unidad desplegable (en caliente). Consulta la documentación de JBoss AS para más información sobre el servicio JMX y despliegue de EJB."
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr ""
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr ""
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr ""
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr ""
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,348 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr "Interceptores y eventos"
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr "Frecuentemente es útil para la aplicación reaccionar a ciertos eventos que ocurran dentro de Hibernate. Esto permite la implementación de ciertos tipos de funcionalidade genérica, y extensión de la funcionalidad de Hibernate."
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr "Interceptores"
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr "La interface <literal>Interceptor</literal> provee callbacks desde la sesión a la aplicación permitiendo a ésta última inspeccionar y/o manipular las propiedades de un objeto persistente antes que sea salvado, actualizado, borrado o cargado. Un uso posible de esto es seguir la pista de información de auditoría. Por ejemplo, el siguiente <literal>Interceptor</literal> establece automáticamente el <literal>createTimestamp</literal> cuando un <literal>Auditable</literal> es creado y actualiza la propiedad <literal>lastUpdateTimestamp</literal> cuando un <literal>Auditable</literal> es acutalizado."
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.Interceptor;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor implements Interceptor, Serializable {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void postFlush(Iterator entities) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates);\n"
+ " }\n"
+ "\n"
+ " public void preFlush(Iterator entities) {\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " }\n"
+ "\n"
+ " ...\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "El interceptor podría ser especificado cuando se crea la sesión:"
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr "Puedes además establecer un interceptor a un nivel global, usando la <literal>Configuration</literal>:"
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr "Sistema de eventos"
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr "Si tienes que reaccionar a eventos particulares en tu capa de persistencia, puedes también la arquitectura de <emphasis>eventos</emphasis> de Hibernate3. El sistema de eventos puede ser usado en adición o como un remplazo a los interceptores."
+
+#: index.docbook:61
+msgid "Event system"
+msgstr "Esencialmente todos los métodos de la interface <literal>Session</literal> se correlacionan con un evento. Tienes un <literal>LoadEvent</literal>, un <literal>FlushEvent</literal>, etc (consulta el DTD del fichero de configuración XML o el paquete <literal>org.hibernate.event</literal> para la lista completa de tipos de evento definidos). Cuando se hace una petición de uno de estos métodos, la <literal>Session</literal> de Hibernate genera un evento apropiado y se lo pasa al oyente (listener) de eventos configurado para ese tipo. De fábrica, estos oyentes implementan el mismo procesamiento en los que siempre resultan aquellos métodos. Sin embargo, eres libre de implementar una personalización de una de las interfaces oyentes (es decir, el <literal>LoadEvent</literal> es procesado por la implementación registrada de la interface <literal>LoadEventListener</literal>), en cuyo caso su implementación ser�!
0ed;a responsable de procesar cualquier petición <literal>load()</literal> hecha a la <literal>Session</literal>."
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr "Los oyentes deben ser considerados efectivamente singletons; quiere decir, que son compartidos entre las peticiones, y por lo tanto no guardan ningún estado en variables de instancia."
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr "Un oyente personalizado debe implementar la interface apropiada para el evento que quiere procesar y/o extender una de las clases base de conveniencia (o incluso los oyentes de eventos por defecto usados por Hibernate de fábrica al ser éstos declarados non-final para este propósito). Los oyentes personalizados pueden ser registrados programáticamente a través del objeto <literal>Configuration</literal>, o especificados en el XML de configuración de Hibernate (la declaración declarativa a través del fichero de propiedades no está soportada). He aquí un ejemplo de un oyente personalizado de eventos load:"
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr ""
+ "<![CDATA[public class MyLoadListener extends DefaultLoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public Object onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " return super.onLoad(event, loadType);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr "Necesitas además una entrada de configuración diciéndole a Hibernate que use el oyente en vez del oyente por defecto:"
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <listener type=\"load\" class=\"MyLoadListener\"/>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr "En cambio, puedes registrarlo programáticamente:"
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "cfg.getSessionEventListenerConfig().setLoadEventListener( new MyLoadListener() );]]>"
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr "Los oyentes registrados declarativamente no pueden compartir instancias. Si el mismo nombre de clase es usado en múltiples elementos <literal><listener/></literal>, cada referencia resultará en una instancia separada de esa clase. Si necesitas la capacidad de compartir instancias de oyentes entre tipos de oyente debes usar el enfoque de registración programática."
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr "¿Por qué implementar una interface y definir el tipo espcífico durante la configuración? Bueno, una implementación de oyente podría implementar múltiples interfaces de oyente de eventos. Teniendo el tipo definido adicionalmente durante la registración lo hace más fácil para activar o desactivar oyentes personalizados durante la configuración."
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr "Seguridad declarativa de Hibernate"
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr "Usualmente, la seguridad declarativa en aplicaciones Hibernate es manejada en una capa de fachada de sesión. Ahora, Hibernate3 permite que ciertas acciones sean permitidas vía JACC, y autorizadas vía JAAS. Esta en una funcionalidad opcional construída encima de la arquitectura de eventos."
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr "Primero, debes configurar los oyentes de eventos apropiados, para habilitar el uso de autorización JAAS."
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr "Seguido, aún en <literal>hibernate.cfg.xml</literal>, liga los permisos a roles:"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr "Los nombres de role son los roles entendidos por tu proveedor de JACC."
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr ""
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1162 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr "Ejemplo: Varios Mapeos"
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr "Este capítulo muestra mapeos de asociaciones más complejos."
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr "Empleador/Empleado"
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr "El siguiente modelo de la relación entre <literal>Employer</literal> y <literal>Employee</literal> usa una clase de entidad real (<literal>Employment</literal>) para representar la asociación. Esto se ha hecho esto porque podría haber más de un período de empleo para los mismos dos participantes. Se usan componentes para modelar valores monetarios y nombres de empleado."
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr "He aquí un documento de mapeo posible:"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr "Y he aquí el esquema de tablas generado por <literal>SchemaExport</literal>."
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr "Autor/Obra"
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr "Considera el siguiente modelo de las relaciones entre <literal>Work</literal>, <literal>Author</literal> y <literal>Person</literal>. Representamos la relación entre <literal>Work</literal> y <literal>Author</literal> como una asociación muchos-a-muchos. Elegimos representar la relación entre <literal>Author</literal> y <literal>Person</literal> como una asociación uno-a-uno. Otra posibilidad hubiese sido que <literal>Author</literal> extendiera <literal>Person</literal>."
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr "El siguiente documento de mapeo representa estas relaciones correctamente:"
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr "Hay cuatro tablas en este mapeo. <literal>works</literal>, <literal>authors</literal> y <literal>persons</literal> tienen los datos de obra, autor y persona respectivamente. <literal>author_work</literal> es una tabla de asociación enlazando autores a obras. He aquí el esquema de tablas, tal como fue generado por <literal>SchemaExport</literal>."
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr "Cliente/Orden/Producto"
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr "Ahora considera un modelo de las relaciones entre <literal>Customer</literal>, <literal>Order</literal> y <literal>LineItem</literal> y <literal>Product</literal>. Hay una asociación uno-a-muchos entre <literal>Customer</literal> y <literal>Order</literal>, pero, ¿cómo deberíamos representar <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? He elegido mapear <literal>LineItem</literal> como una clase de asociación representando la asociación muchos-a-muchos entre <literal>Order</literal> y <literal>Product</literal>. En Hibernate, esto se llama un elemento compuesto."
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr "El documento de mapeo:"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> y <literal>products</literal> tienen los datos de cliente, orden, ítem de línea de orden y producto respectivamente. Además <literal>line_items</literal> actúa como una tabla de asociación enlazando órdenes con productos."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr "Mapeos misceláneos de ejemplo"
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr "Todos estos ejemplos están tomados de la batería de pruebas de Hibernate. Encontrarás muchos otros mapeos de ejemplo útiles allí. Mira en la carpeta <literal>test</literal> de la distribución de Hibernate."
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr "POR HACER: poner palabras alrededor de este material"
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr "Asociación uno-a-uno \"Tipificada\""
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr "Ejemplo de clave compuesta"
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr "Muchos-a-muchos con atributo de clave compuesta compartido"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr "Discriminación basada en contenido"
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr "Asociaciones sobre claves alternativas"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid.hex\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,350 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr "Ejemplo: Padre/Hijo"
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr "Una de las primerísimas cosas que los usuarios nuevos intentan hacer con Hibernate es modelar una relación de tipo padre / hijo. Para esto hay dos enfoques diferentes. Por varias razones, el enfoque más conveniente, especialmente para usuarios nuevos, es modelar tanto <literal>Parent</literal> como <literal>Child</literal> como clases de entidad con una asociación <literal><one-to-many></literal> desde <literal>Parent</literal> a <literal>Child</literal>. (El enfoque alternativo es declarar el <literal>Child</literal> como un <literal><composite-element></literal>.) Ahora, resulta que la semántica por defecto de una asociación uno a muchos (en Hibernate) es mucho menos cercana a la semántica usual de una relación padre / hijo que aquellas de un mapeo de elementos compuestos. Explicaremos cómo usar una <emphasis>asociación uno a muchos bidireccional con tratamiento en cascada</emphasis>!
para modelar una relación padre / hijo eficiente y elegantemente. ¡No es para nada difícil!"
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr "Una nota sobre las colecciones"
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr "Se considera que las colecciones de Hibernate son una parte lógica de la entidad que las posee; nunca de las entidades contenidas. ¡Esta es una distinción crucial! Esto tiene las siguientes consecuencias:"
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr "Cuando se quita / añade un objeto desde / a una colección, se incrementa el número de versión del dueño de la colección."
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr "Si un objeto que fue quitado de una colección es una instancia de un tipo de valor (por ejemplo, un elemento compuesto), ese objeta cesará de ser persistente y su estado será completamente quitado de la base de datos. Asimismo, añadir una instancia de tipo de valor a la colección causará que su estado sea inmediatamente persistente."
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr "Por otro lado, si se quita una entidad de una colección (una asociación uno-a-muchos o muchos-a-muchos), no será borrado, por defecto. Este comportamiento es completamente consistente. ¡Un cambio en el estado interno de otra entidad no hace desaparecer la entidad asociada! Asimismo, añadir una entidad a una colección no causa que la entidad se vuelva persistente, por defecto."
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr "En cambio, el comportamiento por defecto es que al añadir una entidad a una colección se crea meramente un enlace entre las dos entidades, mientras que al quitarla se quita el enlace. Esto es muy apropiado para todos los tipos de casos. Donde no es para nada apropiado es en el caso de una relación padre / hijo. donde la vida del hijo está ligada al ciclo de vida del padre."
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr "Uno-a-muchos bidirectional"
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr "Supón que empezamos con una asociación simple <literal><one-to-many></literal> desde <literal>Parent</literal> a <literal>Child</literal>."
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr "Si ejecutásemos el siguiente código"
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr "Hibernate publicaría dos sentencias SQL:"
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr "un <literal>INSERT</literal> para crear el registro de <literal>c</literal>"
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr "un <literal>UPDATE</literal> para crear el enlace desde <literal>p</literal> a <literal>c</literal>"
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr "Esto no es sólo ineficiente, sino que además viola cualquier restricción <literal>NOT NULL</literal> en la columna <literal>parent_id</literal>. Podemos reparar la violación de restricción de nulabilidad especificando <literal>not-null=\"true\"</literal> en el mapeo de la colección:"
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr "Sin embargo, esta no es la solución recomendada."
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr "El caso subyacente de este comportamiento es que el enlace (la clave foránea <literal>parent_id</literal>) de <literal>p</literal> a <literal>c</literal> no es considerado parte del estado del objeto <literal>Child</literal> y por lo tanto no es creada en el <literal>INSERT</literal>. De modo que la solución es hacer el enlace parte del mapeo del <literal>Child</literal>."
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr "(Necesitamos además añadir la propiedad <literal>parent</literal> a la clase <literal>Child</literal>.)"
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr "Ahora que la entidad <literal>Child</literal> está gestionando el estado del enlace, le decimos a la colección que no actualice el enlace. Usamos el atributo <literal>inverse</literal>."
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr "El siguiente código podría ser usado para añadir un nuevo <literal>Child</literal>"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr "Y ahora, ¡Sólo se publicaría un <literal>INSERT</literal> de SQL!"
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr "Para ajustar un poco más las cosas, podríamos crear un método <literal>addChild()</literal> en <literal>Parent</literal>."
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr "Ahora, el código para añadir un <literal>Child</literal> se ve así"
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr "Ciclo de vida en cascada"
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr "La llamada explícita a <literal>save()</literal> es aún molesta. Apuntaremos a esto usando tratamientos en cascada."
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr "Esto simplifica el código anterior a"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr "Similarmente, no necesitamos iterar los hijos al salvar o borrar un <literal>Parent</literal>. Lo siguiente quita <literal>p</literal> y todos sus hijos de la base de datos."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr "Sin embargo, este código"
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr "no quitará <literal>c</literal> de la base de datos; sólo quitará el enlace a <literal>p</literal> (y causará una violación a una restricción <literal>NOT NULL</literal>). Necesitas borrar el hijo explícitamente llamando a <literal>delete()</literal>."
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr "Ahora, en nuestro caso, un <literal>Child</literal> no puede existir realmente sin su padre. De modo que si quitamos un <literal>Child</literal> de la colección, realmente queremos que sea borrado. Para esto, debemos usar <literal>cascade=\"all-delete-orphan\"</literal>."
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr "Nota: aunque el mapeo de la colección especifique <literal>inverse=\"true\"</literal>, el tratamiento en cascada se procesa aún al iterar los elementos de colección. De modo que si requieres que un objeto sea salvado, borrado o actualizado en cascada, debes añadirlo a la colección. No es suficiente con simplemente llamar a <literal>setParent()</literal>."
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr "Tratamiento en cascada y <literal>unsaved-value</literal>"
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr "Supón que hemos cargado un <literal>Parent</literal> en una <literal>Session</literal>, hemos hecho algunos cambios en una acción de UI y deseamos hacer persistentes estos cambios en una nueva sesión llamando a <literal>update()</literal>. El <literal>Parent</literal> contendrá una colección de hijos y, ya que está habilitado el tratamiento en cascada, Hibernate necesita saber qué hijos están recién instanciados y cuáles representan filas existentes en la base de datos. Asumamos que tanto <literal>Parent</literal> como <literal>Child</literal> tienen propiedades identificadoras generadas de tipo <literal>Long</literal>. Hibernate usará el identificador y el valor de la propiedad de versión/timestamp para determinar cuáles de los hijos son nuevos. (Ver <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>En Hibernate3, no es más necesario especificar un <literal>unsa!
ved-value</literal> explícitamente.</emphasis>"
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr "Bueno, todo eso está muy bien para el caso de un identificador generado, pero ¿qué de los identificadores asignados y de los identificadores compuestos? Esto es más difícil, ya que Hibernate no puede usar la propiedad identificadora para distinguir entre un objeto recién instanciado (con un identificador asignado por el usuario) y un objeto cargado en una sesión previa. En este caso, Hibernate bien usará la propiedad de versión o timestamp, o bien consultará realmente el caché de segundo nivel, o bien, en el peor de los casos, la base de datos, para ver si existe la fila."
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr "Conclusión"
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr "Hay que resumir un poco aquí y podría parecer confuso a la primera vez. Sin embargo, en la práctica, todo funciona muy agradablemente. La mayoría de las aplicaciones de Hibernate usan el patrón padre / hijo en muchos sitios."
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr "Hemos mencionado una alternativa en el primer párrafo. Ninguno de los temas anteriores existe en el caso de los mapeos <literal><composite-element></literal>, que tienen exactamente la semántica de una relación padre / hijo. Desafortunadamente, hay dos grandes limitaciones para las clases de elementos compuestos: los elementos compuestos no pueden poseer sus propias colecciones, y no deben ser el hijo de cualquier otra entidad que no sea su padre único."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,840 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr "Ejemplo: Aplicación de Weblog"
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr "Clases Persistentes"
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr "Las clases persistentes representan un weblog, y un ítem enviado a un weblog. Van a ser modelados como una relación padre/hijo estñndar, pero usaremos un bag ordenado, en vez de un conjunto (set)."
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr "Mapeos de Hibernate"
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr "Los mapeos XML ahora deben ser absolutamente directos."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr "Código Hibernate"
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr "La siguiente clase demuestra algunos de los tipos de cosas que podemos haces con estas clases, usando Hibernate."
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,192 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr "Filtrando datos"
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr "Hibernate3 provee un nuevo enfoque innovador para manejar datos con reglas de \"visibilidad\". Un <emphasis>filtro de Hibernate</emphasis> es un filtro global, con nombre y parametrizado que puede ser habilitado o deshabilitado para una sesión de Hibernate en particular."
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr "Filtros de Hibernate"
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr "Hibernate3 añade la habilidad de predefinir criterios de filtros y unir esos filtros tanto a nivel de una clase como de una colección. Un criterio de filtro es la habilidad de definir una cláusula de restricción muy similar al atributo existente \"where\" disponible en el elemento class y varios elementos de colección. Excepto en que estos filtros pueden ser parametrizados. La aplicación puede tomar la decisión en tiempo de ejecución de qué filtros deben estar habilitados y cuáles deben ser sus parámetros. Los filtros pueden ser usados como vistas de base de datos, pero parametrizados dentro de la aplicación."
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr "Para usar los filtros, éstos deben primero ser definidos y luego unidos a los elementos de mapeo apropiados. Para definir un filtro, usa el elemento <literal><filter-def/></literal> dentro de un elemento <literal><hibernate-mapping/></literal>:"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr "Entonces este filtro puede ser unido a una clase:"
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr "o a una colección:"
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr "o incluso a ambos (o muchos de cada uno) al mismo tiempo."
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr "Los métodos en <literal>Session</literal> son: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, y <literal>disableFilter(String filterName)</literal>. Por defecto, los filtros <emphasis>no</emphasis> están habilitados para una sesión dada; deben ser habilitados explÃcitamente por medio del uso del método <literal>Session.enableFilter()</literal>, que devuelve una instancia de la interface <literal>Filter</literal>. Usando el filtro simple definido arriba, esto se verÃa asÃ:"
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr "Nota que los métodos en la interface org.hibernate.Filter permiten el encadenamiento de métodos común en gran parte de Hibernate."
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr "Un ejemplo completo, usando datos temporales con un patrón efectivo de fechas de registro:"
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr "Entonces, en orden de asegurar que siempre tendrás de vuelta registros actualmente efectivos, simplemente habilita el filtro en la sesión previo a recuperar los datos de empleados:"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr "En el HQL de arriba, aunque sólo hemos mencionado explÃcitamente una restricción de salario en los resultados, debido al filtro habilitado la consulta sólo devolverá empleados actualmente activos que tengan un salario mayor que un millón de dólares."
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr "Nota: si planeas usar filtros con unión externa (outer joining) (bien a través de HQL, o bien de recuperación de carga) sé cuidadoso en la dirección de expresión de la condición. Lo más seguro es establecer esto para unión externa izquierda (left outer joining). En general, coloca el primer parámetro seguido del nombre(s) de columna(s) después del operador."
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,636 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr "Mapeo de Herencia"
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr "Las Tres Estrategias"
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr "Hibernate soporta las tres estrategias básicas de mapeo de herencia:"
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr "<para>tabla por jerarquía de clases</para>"
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr "<para>tabla por subclase</para>"
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr "tabla por clase concreta"
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr "En adición, Hibernate soporta un cuarto, ligeramente diferente tipo de polimorfismo:"
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr "polimorfismo implícito"
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr "Es posible usar estrategias de mapeo diferentes para diferentes ramificaciones de la misma jerarquía de herencia, y entonces usar polimorfismo implícito para conseguir polimorfismo a través de toda la jerarquía. Sin embargo, Hibernate no soporta la mezcla de mapeos <literal><subclass></literal>, y <literal><joined-subclass></literal> y <literal><union-subclass></literal> bajo el mismo elemento <literal><class></literal> raíz. Es posible mezclar juntas las estrategias de tabla por jerarquía y tabla por subclase, bajo el mismo elemento <literal><class></literal>, combinando los elementos <literal><subclass></literal> y <literal><join></literal> (ver debajo)."
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr "Tabla por jerarquía de clases"
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr "Supón que tenemos una interface <literal>Payment</literal>, con los implementadores <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. El mapeo de tabla por jerarquía se vería así:"
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr "Se requiere exactamente una tabla. Hay una gran limitación de esta estrategia de mapeo: las columnas declaradas por las subclases, como <literal>CCTYPE</literal>, no pueden tener restricciones <literal>NOT NULL</literal>."
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr "Tabla por subclase"
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr "Un mapeo de tabla por sublclase se vería así:"
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr "Se requieren cuatro tablas. Las tres tablas de subclase tienen asociaciones de clave primaria a la tabla de superclase (de modo que en el modelo relacional es realmente una asociación uno-a-uno)."
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr "Tabla por subclase, usando un discriminador"
+
+#: index.docbook:102
+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 "Observa que la implementación de Hibernate de tabla por subclase no requiere ninguna columna discriminadora. Otros mapeadores objeto/relacional usan una implementación diferente de tabla por subclase que requiere una columna discriminadora de tipo en la tabla de superclase. Este enfoque es mucho más difícil de implementar pero discutiblemente más correcto desde un punto de vista relacional. Si quisieras usar una columna discriminadora con la estrategia de tabla por subclase, puedes combinar el uso de <literal><subclass></literal> y <literal><join></literal>, como sigue:"
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr "la declaración opcional <literal>fetch=\"select\"</literal> dice a Hibernate que no recupere los datos de la subclase <literal>ChequePayment</literal> usando una unión externa (outer join) al consultar la superclase."
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr "Mezclando tabla por jerarquía de clases con tabla por subclase"
+
+#: index.docbook:127
+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 "Puedes incluso mezclar las estrategias de tabla po jerarquía y tabla por subclase usando este enfoque:"
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr "Para cualquiera de estas estrategias de mapeo, una asociación polimórfica a la clase raíz <literal>Payment</literal> es mapeada usando <literal><many-to-one></literal>."
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr "Tabla por clase concreta"
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr "Podríamos ir de dos maneras a la estrategia de mapeo de tabla por clase concreta. La primera es usar <literal><union-subclass></literal>."
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr "Están implicadas tres tablas. Cada tabla define columnas para todas las propiedades de la clase, inccluyendo las propiedades heredadas."
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr "La limitación de este enfoque es que si una propiedad es mapeada en la superclase, el nombre de columna debe ser el mismo en todas las tablas de subclase. (Podríamos relajar esto en un lanzamiento futuro de Hibernate.) La estrategia de generador de indentidad no está permitida en la herencia de unión de subclase, de hecho la semilla de clave primaria tiene que ser compartida a través de todas las subclases unidas de una jerarquía."
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr "Tabla por clase concreta, usando polimorfismo implícito"
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr "Un enfoque alternativo es hacer uso de polimorfismo implícito:"
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr "Nota que en ningún sitio mencionamos la interface <literal>Payment</literal> explícitamente. Nota además que las propiedades de <literal>Payment</literal> son mapeadas en cada una de las subclases. Si quieres evitar duplicación, considera usar entidades XML. (por ejemplo, <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> en la declaración <literal>DOCTYPE</literal> y <literal>&allproperties;</literal> en el mapeo)."
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr "La desventaja de este enfoque es que Hibernate no genera <literal>UNION</literal>s de SQL al realizar consultas polimórficas."
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr "Para esta estrategia de mapeo, una asociación polimórfica a <literal>Payment</literal> es mapeada generalmente usando <literal><any></literal>."
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr "Mezclando polimorfismo implícito con otros mapeos de herencia"
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr "Hay una cosa más por notar acerca de este mapeo. Ya que las subclases se mapean cada una en su propio elemento <literal><class></literal> (y ya que <literal>Payment</literal> es sólo una interface), cada una de las subclases podría ser parte de otra jerarquía de herencia! (Y todavía puedes seguir usando consultas polimórficas contra la interface <literal>Payment</literal>.)"
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr "Una vez más, no mencionamos a <literal>Payment</literal> explícitamente. Si ejecutamos una consulta contra la interface <literal>Payment</literal> - por ejemplo, <literal>from Payment</literal> - Hibernate devuelve automáticamente instancias de <literal>CreditCardPayment</literal> (y sus subclases, ya que ellas también implementan <literal>Payment</literal>), <literal>CashPayment</literal> y <literal>ChequePayment</literal> pero no instancias de <literal>NonelectronicTransaction</literal>."
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr "Limitaciones"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr "Existen ciertas limitaciones al enfoque de \"polimorfismo implícito\" en la estrategia de mapeo de tabla por clase concreta. Existen limitaciones algo menos restrictivas a los mapeos <literal><union-subclass></literal>."
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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 "La siguiente tabla muestra las limitaciones de mapeos de tabla por clase concreta, y de polmorfismo implícito, en Hibernate."
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr "Funcionalidades de mapeo de herencia"
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr "Estrategia de herencia"
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr "muchos-a-uno polimórfica"
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr "uno-a-uno polimórfica"
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr "uno-a-muchos polimórfica"
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr "mushos-a-muchos polimórfica"
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr "<literal>load()/get()</literal> polimórficos"
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr "Consultas polimórficas"
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr "Uniones polimórficas"
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr "Recuperación por unión externa (outer join)"
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr "<entry>tabla por jerarquía de clases</entry>"
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr "<many-to-one>"
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr "<one-to-one>"
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr "<one-to-many>"
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr "<many-to-many>"
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr "s.get(Payment.class, id)"
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr "from Payment p"
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr "from Order o join o.payment p"
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr "soportada"
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr "<entry>tabla por subclase</entry>"
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr "<many-to-one>"
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr "<one-to-one>"
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr "<one-to-many>"
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr "<literal><one-to-many></literal> (para <literal>inverse=\"true\"</literal> solamente)"
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr "from Payment p"
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr "no soportada"
+
+#: index.docbook:323
+msgid "<any>"
+msgstr "<many-to-any>"
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr "no suportadas"
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr "no soportada"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1208 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr "Mejorando el rendimiento"
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr "Estrategias de recuperación"
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr "Una <emphasis>estrategia de recuperación</emphasis> es la estrategia que usará Hibernate para recuperar los objetos asociados cuando la aplicación necesite navegar la asociación. Las estrategias de recuperación pueden ser declaradas en los metadatos de mapeo O/R, o sobrescritas por una consulta HQL o <literal>Criteria</literal> en particular."
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr "Hibernate3 define las siguientes estrategias de recuperación:"
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr "<emphasis>Recuperación por unión (join fetching)</emphasis> - Hibernate recupera la instancia asociada o colección en la misma <literal>SELECT</literal>, usando una <literal>OUTER JOIN</literal>."
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Recuperación por selección (select fetching)</emphasis> - se usa una segunda <literal>SELECT</literal> para recuperar la entidad asociada o colección. A menos que deshabilites explícitamente la recuperación perezosa especificando <literal>lazy=\"false\"</literal>, la segunda selección sólo será ejecutada cuando realmente accedas a la asociación."
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Recuperación por subselección (subselect fetching)</emphasis> - se usa una segunda <literal>SELECT</literal> para recuperar las colecciones asociadas de todas las entidades recuperadas en una consulta o recuperación previa. A menos que deshabilites explícitamente la recuperación perezosa especificando <literal>lazy=\"false\"</literal>, esta segunda selección sólo será ejecutada cuando realmente accedas a la asociación."
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr "<emphasis>Recuperación en lote</emphasis> - una estrategia de optimización para la recuperación por selección - Hibernate recupera un lote de instancias de entidad o colecciones en una sola <literal>SELECT</literal>, especificando una lista de claves primarias o de claves foráneas."
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr "Hibernate también distingue entre:"
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr "<emphasis>Recuperación inmediata</emphasis> - una asociación, colección o atributo es recuperado inmediatamente, cuando el dueño es cargado."
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr "<emphasis>Recuperación perezosa de colecciones</emphasis> - se recupera una colección cuando la aplicación invoca una operación sobre la colección. (Esto es por defecto para las colecciones.)"
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr "<emphasis>Recuperación por proxy</emphasis> - se recupera una asociación monovaluada cuando se invoca un método que no sea el getter del identificador sobre el objeto asociado."
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr "<emphasis>Recuperación perezosa de atributos</emphasis> - se recupera un atributo o una asociación monovaluada cuando se accede a la variable de instancia (requiere instrumentación del bytecode en tiempo de ejecución). Este enfoque es raramente necesario."
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "Aquí tenemos dos nociones ortogonales: <emphasis>cuándo</emphasis> se recupera la aplicación, y <emphasis>cómo</emphasis> es recuperada (qué SQL es usado). ¡No las confundas! Usamos <literal>fetch</literal> para afinar el rendimiento. Podemos usar <literal>lazy</literal> para definir un contrato sobre qué datos están siempre disponibles en cualquier instancia separada de una clase en particular."
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "Trabajando con asociaciones perezosas"
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr "Por defecto, Hibernate3 usa una recuperación perezosa por selección para colecciones y una recuperación por proxy perezosa para asociaciones monovaluadas. Estas políticas por defecto tienen sentido para casi todas las asociaciones en casi todas las aplicaciones."
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr "<emphasis>Nota:</emphasis> si estableces <literal>hibernate.default_batch_fetch_size</literal>, Hibernate usará la optimización de recuperación en lotes para recuperación perezosa (esta optimización también puede ser habilitada a un nivel más granularizado)."
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr "Sin embargo, la recuperación perezosa plantea un problema del que tienes que estar al tanto. Acceder a una asociación perezosa fuera del contexto de una sesión de Hibernate abierta resultará en una excepción. Por ejemplo:"
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr "Ya que la colección de permisos no fue inicializada cuando se cerró la <literal>Session</literal>, la colección no será capaz de cargar su estado. <emphasis>Hibernate no soporta la inicialización perezosa de objetos separados</emphasis>. La solución es mover el código que lee de la colección a justo antes que la transacción sea comprometida."
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr "Alternativamente, podríamos usar una colección no perezosa o asociación, especificando <literal>lazy=\"false\"</literal> para el mapeo de asociación. Sin embargo, está pensado que la inicialización perezosa sea usada para casi todas las colecciones y asociaciones. ¡Si defines demasiadas asociaciones no perezosas en tu modelo de objetos, Hibernate terminará necesitando recuperar la base de datos entera en cada transacción!"
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr "Por otro lado, frecuentemente necesitamos elegir la recuperación por unión (que es no perezosa por naturaleza) en vez de la recuperación por selección en una transacción en particular. Veremos ahora cómo personalizar la estrategia de recuperación. En Hibernate3, los mecanismos para elegir una estrategia de recuperación son idénticas a las de las asociaciones monovaluadas y colecciones."
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr "Afinando las estrategias de recuperación"
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr "La recuperación por selección (la preestablecida) es extremadamente vulnerable a problemas de selección N+1, de modo querríamos habilitar la recuperación por unión (join fetching) en el documento de mapeo:"
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr "La estrategia de recuperación definida en el documento de mapeo afecta a:"
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr "las recuperaciones vía <literal>get()</literal> o <literal>load()</literal>"
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr "las recuperaciones que ocurren implícitamente cuando se navega una asociación (recuperación perezosa)"
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr "las consultas de <literal>Criteria</literal>"
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr "Usualmente, no usamos el documento de mapeo para personalizar la recuperación. En cambio, mantenemos el comportamiento por defecto, y lo sobrescribimos para una transacción en particular, usando <literal>left join fetch</literal> en HQL. Esto le dice a Hibernate que recupere la asociación tempranamente en la primera selección, usando una unión externa. En la API de consulta de <literal>Criteria</literal>, usarías <literal>setFetchMode(FetchMode.JOIN)</literal>."
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr "Si acaso lo deseases, podrías cambiar la estrategia de recuperación usada por <literal>get()</literal> or <literal>load()</literal>; simplemente usa una consulta <literal>Criteria</literal>, por ejemplo:"
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr "(Esto es el equivalente de Hibernate de lo que otras soluciones ORM llaman un \"plan de recuperación\".)"
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr "Una forma completamente diferente de evitar problemas con selecciones N+1 es usar el caché de segundo nivel."
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr "Proxies de asociaciones de un solo extremo"
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr "La recuperación perezosa de colecciones está implementada usando la implementación de colecciones persistentes propia de Hibernate. Sin embargo, se necesita un mecanismo diferente para un comportamiento perezoso en las asociaciones de un solo extremo. La entidad objetivo de la asociación debe ser tratada con proxies. Hibernate implementa proxies de inicialización perezosa para objetos persistentes usando mejora del bytecode en tiempo de ejecución (por medio de la excelente biblioteca CGLIB)."
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr "Por defecto, Hibernate3 genera proxies (en el arranque) para todas las clases persistentes y los usa para habilitar la recuperación perezosa de asociaciones <literal>muchos-a-uno</literal> y <literal>uno-a-uno</literal>."
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr "El fichero de mapeo puede declarar una interface a usar como interface de proxy para esa clase, con el atributo <literal>proxy</literal>. Por defecto, Hibernate usa una subclase de la clase. <emphasis>Nota que la clase tratada con proxies debe implementar un constructor por defecto con al menos visibilidad de paquete. ¡Recomendamos este constructor para todas las clases persistentes!</emphasis>"
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr "Hay algunos puntos a tener en cuenta al extender este enfoque a clases polimórficas, por ejemplo."
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr "Primero, las instancias de <literal>Cat</literal> nunca serán objeto de un cast a <literal>DomesticCat</literal>, incluso aunque la instancia subyacente sea instancia de <literal>DomesticCat</literal>:"
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr "Segundo, es posible romper con el operador <literal>==</literal> de un proxy."
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr "Sin embargo, la situación no en absoluta tan mala como parece. Aunque tenemos ahora dos referencias a objetos proxy diferentes, la instancia subyacente será aún el mismo objeto:"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr "Tercero, no debes usar un proxy CGLIB para una clase <literal>final</literal> o una clase con algún método <literal>final</literal>."
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr "Finalmente, si tu objeto persistente adquiere cualquier recurso bajo instanciación (por ejemplo, en inicializadores o constructores por defecto), entonces esos recursos serán adquiridos también por el proxy. La clase del proxy es una subclase real de la clase persistente."
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr "Estos problemas se deben a limitaciones fundamentales en el modelo de herencia única de Java. Si deseas evitar estos problemas cada una de tus clases persistentes deben implementar una interface que declare sus métodos de negocio. Debes especificar estas interfaces en el fichero de mapeo. Por ejemplo:"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr "donde <literal>CatImpl</literal> implementa la interface <literal>Cat</literal> y <literal>DomesticCatImpl</literal> implementa la interface <literal>DomesticCat</literal>. Entonces <literal>load()</literal> o <literal>iterate()</literal> pueden devolver instancias de <literal>Cat</literal> y <literal>DomesticCat</literal>. (Nota que <literal>list()</literal> usualmente no devuelve proxies.)"
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr "Las relaciones también son inicializadas perezosamente. Esto significa que debes declarar cualquier propiedad como de tipo <literal>Cat</literal>, no <literal>CatImpl</literal>."
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr "Ciertas operaciones <emphasis>no</emphasis> requieren inicialización de proxies."
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr "<literal>equals()</literal>, si la clase persistente no sobrescribe <literal>equals()</literal>"
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr "<literal>hashCode()</literal>, si la clase persistente no sobrescribe <literal>hashCode()</literal>"
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr "El método getter del identificador"
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr "Hibernate detectará las clase persistentes que sobrescriban <literal>equals()</literal> o <literal>hashCode()</literal>."
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr "Inicializando colecciones y proxies"
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr "Una <literal>LazyInitializationException</literal> será lanzada por Hibernate si una colección o proxy sin inicializar es accedido fuera del ámbito de la <literal>Session</literal>, es decir, cuando la entidad que posee la colección o que tiene la referencia al proxy esté en el estado separada."
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr "A veces necesitamos asegurarnos que un proxy o colección esté inicializado antes de cerrar la <literal>Session</literal>. Por supuesto, siempre podemos forzar la inicialización llamando a <literal>cat.getSex()</literal> o <literal>cat.getKittens().size()</literal>, por ejemplo. Pero esto es confuso a lectores del código y no es conveniente para código genérico."
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr "Los métodos estáticos <literal>Hibernate.initialize()</literal> y <literal>Hibernate.isInitialized()</literal> proveen a la aplicación de una forma conveniente de trabajar con colecciones o proxies inicializados perezosamente. <literal>Hibernate.initialize(cat)</literal> forzará la inicialización de un proxy, <literal>cat</literal>, en tanto su <literal>Session</literal> esté todavía abierta. <literal>Hibernate.initialize( cat.getKittens() )</literal> tiene un efecto similar para la colección de gatitos."
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr "Otra opción es mantener la <literal>Session</literal> abierta hasta que todas las colecciones y proxies necesarios hayan sido cargados. En algunas arquitecturas de aplicación, particularmente en aquellas donde el código que accede a los datos usando Hibernate, y el código que los usa están en capas de aplicación diferentes o procesos físicos diferentes, puede ser un problema asegurar que la <literal>Session</literal> esté abierta cuando se inicializa una colección. Existen dos formas básicas de tratar este tema:"
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr "En una aplicación basada web, puede usarse un filtro de servlets para cerrar la <literal>Session</literal> sólo bien al final de una petición de usuario, una vez que el rendering de la vista esté completa (el patrón <emphasis>Sesión Abierta en Vista (Open Session in View)</emphasis>). Por supuesto, estos sitios requieren una fuerte demanda de corrección del manejo de excepciones de tu infraestructura de aplicación. Es de una importancia vital que la <literal>Session</literal> esté cerrada y la transacción terminada antes de volver al usuario, incluso cuando ocurra una excepción durante el rendering de la página. Para este enfoque, el filtro de servlet tiene que ser capaz de accceder la <literal>Session</literal>. Recomendamos que se use una variable <literal>ThreadLocal</literal> para tener la <literal>Session</literal> actual (ver el capítulo 1, <xref linkend=\"quickstart-pla!
yingwithcats\"/>, para una implementación de ejemplo)."
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr "En una aplciación con una grada de negocios separada, la lógica de negocio debe \"preparar\" todas las colecciones que se vayan a necesitar por la grada web antes de volver. Esto significa que la grada de negocios debe cargar todos los datos y devolver a la grada de presentación web todos los datos que se requieran para un caso de uso en particular ya inicializados. Usualmente, la aplicación llama a <literal>Hibernate.initialize()</literal> para cada colección que se necesitará en la grada web (esta llamada debe ocurrir antes que la sesión sea cerrada) o recupera la colección tempranamente usando una consulta de Hibernate con una cláusula <literal>FETCH</literal> o una <literal>FetchMode.JOIN</literal> en <literal>Criteria</literal>. Esto es usualmente más fácil si adoptas el patrón <emphasis>Comando</emphasis> en vez de un <emphasis>Fachada de Sesión</emphasis>."
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr "Puedes también adjuntar un objeto cargado previamente a una nueva <literal>Session</literal> con <literal>merge()</literal> o <literal>lock()</literal> antes de acceder a colecciones no inicializadas (u otros proxies). ¡No, Hibernate no, y ciertamente <emphasis>no debe</emphasis> hacer esto automáticamente, ya que introduciría semánticas de transacción ad hoc!"
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr "A veces no quieres inicializar una colección grande, pero necesitas aún alguna informacion sobre ella (como su tamaño) o un subconjunto de los datos."
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr "Puedes usar un filtro de colecciones para obtener el tamaño de una colección sin inicializarla:"
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr "El método <literal>createFilter()</literal> se usa también para recuperar eficientemente subconjuntos de una colección sin necesidad de inicializar toda la colección:"
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr "Usando recuperación en lotes"
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr "Hibernate puede hacer un uso eficiente de la recuperación en lotes, esto es, Hibernate puede cargar muchos proxies sin inicializar si se accede a un proxy (o colecciones). La recuperación en lotes es una optimización de la estrategia de recuperación por selección perezosa. Hay dos formas en que puedes afinar la recuperación en lotes: a nivel de la clase o de la colección."
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr "La recuperación en lotes para clases/entidades es más fácil de entender. Imagina que tienes la siguiente situación en tiempo de ejecución: Tienes 25 instancias de <literal>Cat</literal> cargadas en una <literal>Session</literal>, cada <literal>Cat</literal> tiene una referencia a su <literal>owner</literal>, una <literal>Person</literal>. La clase <literal>Person</literal> está mapeada con un proxy, <literal>lazy=\"true\"</literal>. Si ahora iteras a través de todos los gatos y llamas a <literal>getOwner()</literal> para cada uno, Hibernate por defecto ejecutará 25 sentencias <literal>SELECT</literal> para traer los dueños tratados con proxies. Puedes afinar este comportamiento especificando un <literal>batch-size</literal> en el mapeo de <literal>Person</literal>:"
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr "Hibernate ahora ejecutará sólo tres consultas, el patrón es 10, 10, 5."
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr "También puedes habilitar la recuperación en lotes para colecciones. Por ejemplo, si cada <literal>Person</literal> tiene una colección perezosa de <literal>Cat</literal>s, y hay 10 personas actualmente cargadas en la <literal>Session</literal>, iterar a través de las 10 personas generará 10 <literal>SELECT</literal>s, una para cada llamada a <literal>getCats()</literal>. Si habilitas la recuperación en lotes para la colección de <literal>cats</literal> en el mapeo de <literal>Person</literal>, Hibernate puede recuperar por adelantado las colecciones:"
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr "Con un <literal>batch-size</literal> de 3, Hibernate cargará 3, 3, 3, 1 colecciones en cuatro <literal>SELECT</literal>s. Una vez más, el valor del atributo depende del número esperado de colecciones sin inicializar en una <literal>Session</literal> en particular."
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr "La recuperación de coleccione en lotes es particularmente útil si tienes un árbol anidado de ítems, es decir, el típico patrón de cuenta de materiales. (Aunque un <emphasis>conjunto anidado</emphasis> o una <emphasis>ruta materializada</emphasis> podría ser una mejor opción para árboles que sean de lectura en la mayoría de los casos.)"
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr "Usando recuperación por subselección"
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr "Si una colección perezosa o proxy monovaluado tiene que ser recuperado, Hibernate los carga a todos, volviendo a ejecutar la consulta original en una subselección. Esto funciona de la misma forma que la recuperación en lotes, sin carga fragmentaria."
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr "Usando recuperación perezosa de propiedades"
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr "Hibernate3 soporta la recuperación perezosa de propiedades individuales. Esta técnica de optimización es también conocida como <emphasis>grupos de recuperación (fetch groups)</emphasis>. Por favor, nota que éste es mayormente un aspecto de marketing, ya que en la práctica, optimizar lecturas de filas es mucho más importante que la optimización de lectura de columnas. Sin embargo, cargar sólo algunas propiedades de una clase podría ser útil en casos extremos, cuando tablas heredadas tienen cientos de columnas y el modelo de datos no puede ser mejorado."
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr "Para habilitar la carga perezosa de propiedades, establece el atributo <literal>lazy</literal> en tus mapeos de propiedades:"
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr "¡La carga perezosa de propiedades requiere la instrumentación del bytecode en tiempo de construcción! Si tus clases persistentes no son mejoradas, Hibernate ignorará silenciosamente la configuración perezosa de propiedades y caerá en recuperación inmediata."
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr "Para la instrumentación del bytecode, usa la siguiente tarea Ant:"
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr "Una forma diferente (¿mejor?) de evitar lecturas innecesarias de columnas, al menos para transacciones de sólo lectura es usar las funcionalidades de proyección de consultas HQL o Criteria. Esto evita la necesidad de procesar el bytecode en tiempo de construcción y ciertamente es una solución preferida."
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr "Puedes forzar la usual recuperación temprana de propiedades usando <literal>fetch all properties</literal> en HQL."
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr "El Caché de Segundo Nivel"
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr "Una <literal>Session</literal> de Hibernate es una caché de datos persistentes a nivel de transacción. Es posible configurar un cluster o caché a nivel de JVM (a nivel de <literal>SessionFactory</literal>) sobre una base de clase-a-clase o colección-a-colección. Puedes incluso enchufar una caché en cluster. Sé cuidadoso. Las cachés nunca están al tanto de los cambios hechos por otra aplicación al almacén persistente (aunque pueden ser configurados para expirar regularmente los datos en caché)."
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr "Por defecto, Hibernate usa EHCache para caching a nivel de JVM. (El soporte a JCS ahora está despreciado y será quitado en una futura versión de Hibernate.) Puedes elegir una implementación diferente estableciendo el nombre de una clase que implemente <literal>org.hibernate.cache.CacheProvider</literal> usando la propiedad <literal>hibernate.cache.provider_class</literal>."
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr "Proveedores de Caché"
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr "Caché"
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr "clase del Provedor"
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr "Tipo"
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr "Cluster Seguro"
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr "Caché de Consultas Soportado"
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr "Hashtable (no pensado para uso en producción)"
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr "org.hibernate.cache.HashtableCacheProvider"
+
+#: index.docbook:603
+msgid "Type"
+msgstr "memoria"
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr "sí"
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr "EHCache"
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr "org.hibernate.cache.EhCacheProvider"
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr "memoria, disco"
+
+#: index.docbook:612
+msgid "memory"
+msgstr "sí"
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr "OSCache"
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr "org.hibernate.cache.OSCacheProvider"
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr "memoria, disco"
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr "sí"
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr "org.hibernate.cache.SwarmCacheProvider"
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr "clusterizado (ip multicast)"
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr "org.hibernate.cache.TreeCacheProvider"
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr "clusterizado (ip multicast), transaccional"
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr "sí (replicación)"
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr "sí (requiere sincronización de reloj)"
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr "Mapeos de caché"
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr "El elemento <literal><cache></literal> de una mapeo de clase o colección tiene la siguiente forma:"
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ "/>]]>"
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr "<literal>usage</literal> especifica la estrategia de caching: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> o <literal>read-only</literal>"
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr "Alternativamente (¿preferiblemente?), puedes especificar los elementos <literal><class-cache></literal> y <literal><collection-cache></literal> en <literal>hibernate.cfg.xml</literal>."
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr "El atributo <literal>usage</literal> especifica una <emphasis>estrategia de concurrencia al caché</emphasis>."
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr "Estrategia: sólo lectura (read only)"
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr "Si tu aplicación necesita leer pero nunca modificar las instancias de una clase persistente, puede usarse un caché <literal>read-only</literal>. Esta es la mejor y más simple estrategia. Es incluso perfectamente segura de usar en un cluster."
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr "Estrategia: lectura/escritura (read/write)"
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr "Si la aplicación necesita actualizar datos, un caché <literal>read-write</literal> podría ser apropiado. Esta estrategia de caché nunca debe ser usada si se requiere nivel de aislamiento serializable de transacciones. Si el caché es usado en un entorno JTA, debes especificar la propiedad <literal>hibernate.transaction.manager_lookup_class</literal>, mencionando una estrategia para obtener el <literal>TransactionManager</literal> de JTA. En otros entornos, debes asegurarte que la transacción esté completada cuando se llame a <literal>Session.close()</literal> o <literal>Session.disconnect()</literal>. Si deseas usar esta estrategia en un cluster, debes asegurarte que la implementación de caché subyacente soporta bloqueos. Los provedores de caché internos predeterminados <emphasis>no</emphasis> no lo soportan."
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr "Estrategia: lectura/escritura no estricta (nonstrict read/write)"
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr "Si la aplicación necesita sólo ocasionalmente actualizar datos (es decir, es extremadamente inprobable que dos transacciones intenten actualizar el mismo ítem simultáneamente) y no se requiere de un aislamiento de transacciones estricto, un caché <literal>nonstrict-read-write</literal> podría ser apropiado. Si se usa el caché en un entorno JTA, debes especificar <literal>hibernate.transaction.manager_lookup_class</literal>. En otros entornos, debes asegurarte que la transacción se haya completado cuando se llame a <literal>Session.close()</literal> o <literal>Session.disconnect()</literal>."
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr "Estrategia: transaccional"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr "La estrategia de caché <literal>transactional</literal> brinda soporte a provedores de cachés completamente transaccionales como TreeCache de JBoss. Un caché así, puede sólo ser usado en un entorno JTA y debes especificar <literal>hibernate.transaction.manager_lookup_class</literal>."
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr "Ninguno de los provedores de caché soporta todas las estrategias de concurrencia al caché. La siguiente tabla muestra qué provedores son compatibles con qué estrategias de concurrencia."
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr "Soporte a Estrategia de Concurrencia a Caché"
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr "Caché"
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr "read-only"
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr "nonstrict-read-write"
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr "read-write"
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "transactional"
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr "Hashtable (no pensado para uso en producción)"
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr "sí"
+
+#: index.docbook:775
+msgid "read-only"
+msgstr "sí"
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr "EHCache"
+
+#: index.docbook:777
+msgid "read-write"
+msgstr "sí"
+
+#: index.docbook:778
+msgid "transactional"
+msgstr "sí"
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr "El <literal>CacheMode</literal> controla cómo una sesión en particular interactúa con el caché de segundo nivel."
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr "<literal>CacheMode.NORMAL</literal> - lee ítems desde y escribe ítems hacia el caché de segundo nivel"
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr "<literal>CacheMode.GET</literal> - lee ítems del caché de segundo nivel, pero no escribe al caché de segundo nivel excepto al actualizar datos"
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr "<literal>CacheMode.PUT</literal> - escribe ítems al caché de segundo nivel, pero no lee del caché de segundo nivel"
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr "<literal>CacheMode.REFRESH</literal> - escribe ítems al caché de segundo nivel, pero no lee del caché de segundo nivel, saltándose el efecto de <literal>hibernate.cache.use_minimal_puts</literal>, forzando un refresco del caché de segundo nivel para todos los ítems leídos de la base de datos"
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr "Para navegar por los contenidos de una región de caché de segundo nivel o de consultas, usa la API de <literal>Statistics</literal>:"
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr "Necesitarás habilitar las estadísticas y, opcionalmente, forzar a Hibernate para que guarde las entradas del caché en un formato más entendible por humanos:"
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr "El Caché de Consultas"
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr "Los conjuntos resultado de consultas también pueden tratarse en caché. Esto sólo es útil para consultas que se ejecutan frecuentemente con los mismos parámetros. Para usar el caché de consultas primero debes habilitarlo:"
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr "<![CDATA[hibernate.cache.use_query_cache true]]>"
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr "Esta configuración causa la creación de dos nuevas regiones de caché - una teniendo en caché conjuntos resultado de consulta (<literal>org.hibernate.cache.StandardQueryCache</literal>), el otro teniendo timestamps de las actualizaciones más recientes a tablas consultables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Nota que el caché de consultas no pone en caché el estado de las entidades reales en el conjunto resultado; sólo tiene en caché valores indentificadores y resultados de tipo de valor. De modo que el caché de consultas siempre debe ser usado en conjunción con el caché de segundo nivel."
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr "La mayoría de consultas no se benefician del tratamiento en caché, de modo que por defecto las consultas no son tratadas en caché. Para habilitar el tratamiento en caché, llama a <literal>Query.setCacheable(true)</literal>. Esta llamada permite a la consulta buscar resultados existentes en caché o agregar sus resultados al caché cuando se ejecuta."
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr "Si requieres un control finamente granularizado sobre las políticas de expiración del caché de consultas, puedes especificar una región de caché con nombre para una consulta en particular llamando a <literal>Query.setCacheRegion()</literal>."
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr "Si la consulta debe forzar un refresco de si región del caché de consultas, debes llamar a <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. Esto es particularmente útil en casos donde los datos subyacentes pueden haber sido actualizados por medio de un proceso separado (es decir, no modificados a través de Hibernate) y permite a la aplicación refrescar selectivamente conjuntos resultado de consultas en particular. Esto es una alternativa más eficient al desahuciamiento de una región del caché de consultas vía <literal>SessionFactory.evictQueries()</literal>."
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr "Entendiendo el rendimiento de Colecciones"
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr "Ya hemos llevado un buen tiempo hablando sobre colecciones. En esta sección resaltaremos un par de temas más sobre cómo las colecciones se comportan en tiempo de ejecución."
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr "Taxonomia"
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr "Hibernate define tres tipos básicos de colecciones:"
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr "colecciones de valores"
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr "asociaciones uno a muchos"
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr "asociaciones muchos a muchos"
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr "Esta clasificación distingue las varias tablas y relaciones de clave foránea pero no nos dice absolutamente todo lo que necesitamos saber sobre el modelo relacional. Para entender completamente la estructura relacional y las características de rendimiento, debemos considerar la estructura de la clave primaria que es usada por Hibernate para actualizar o borrar filas de colección. Esto sugiere la siguiente clasificación:"
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr "colecciones indexadas"
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr "conjuntos (sets)"
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr "bolsas (bags)"
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr "Todas las colecciones indexadas (mapas, listas, arrays) tienen una clave primaria consistente de las columnas <literal><key></literal> y <literal><index></literal>. En este caso las actualizaciones de colecciones son usualmente extremadamente eficientes. La clave primaria puede ser indexada fácilmente y una fila en particular puede ser localizada cuando Hibernate intenta actualizarla o borrarla."
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr "Los conjuntos (sets) tienen una clave primaria consistente en <literal><key></literal> y columnas de elemento. Esto puede ser menos eficiente para algunos tipos de elemento de colección, particularmente elementos compuestos o texto largo, o campos binarios. La base de datos puede no ser capaz de indexar una clave primaria compleja eficientemente. Por otra parte, para asociaciones uno a muchos o muchos a muchos, particularmente en el caso de identificadores sintéticos, es probable que sólo sea tan eficiente. (Nota al márgen: si quieres que <literal>SchemaExport</literal> realmente cree la clave primaria de un <literal><set></literal> por ti, debes declarar todas las columnas como <literal>not-null=\"true\"</literal>.)"
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr "Los mapeos de <literal><idbag></literal> definen una clave delegada, de modo que siempre resulten eficientes de actualizar. De hecho, son el mejor caso."
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr "Los bags son el peor caso. Ya que un bag permite valores de elementos duplicados y no tiene ninguna columna índice, no puede definirse ninguna clave primaria. Hibernate no tiene forma de distinguir entre filas duplicadas. Hibernate resuelve este problema quitando completamente (en un solo <literal>DELETE</literal>) y recreando la colección siempre que cambia. Esto podría ser muy ineficiente."
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr "Nota que para una asociación uno-a-muchos, la \"clave primaria\" puede no ser la clave primaria física de la tabla de base de datos; pero incluso en este caso, la clasificación anterior es útil todavía. (Aún refleja cómo Hibernate \"localiza\" filas individuales de la colección.)"
+
+#: index.docbook:994
+msgid "sets"
+msgstr "Las listas, mapas, idbags y conjuntos son las colecciones más eficientes de actualizar"
+
+#: index.docbook:997
+msgid "bags"
+msgstr "Desde la discusión anterior, debe quedar claro que las colecciones indexadas y (usualmente) los conjuntos permiten la operación más eficiente en términos de añadir, quitar y actualizar elementos."
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr "Hay, discutiblemente, una ventaja más que las colecciones indexadas tienen sobre otros conjuntos para las asociaciones muchos a muchos o colecciones de valores. Debido a la estructura de un <literal>Set</literal>, Hibernate ni siquiera actualiza una fila con <literal>UPDATE</literal> cuando se \"cambia\" un elemento. Los cambios a un <literal>Set</literal> siempre funcionan por medio de <literal>INSERT</literal> y <literal>DELETE</literal> (de filas individuales). Una vez más, esta consideración no se aplica a las asociaciones uno a muchos."
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr "Después de observar que los arrays no pueden ser perezosos, podríamos concluir que las listas, mapas e idbags son los tipos más eficientes de colecciones (no inversas), con los conjuntos (sets) no muy por detrás. Se espera que los sets sean el tipo más común de colección en las aplicaciones de Hibernate. Esto es debido a que la semántica de los sets es la más natural en el modelo relacional."
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr "Sin embargo, en modelos de dominio de Hibernate bien dieñados, usualmente vemos que la mayoría de las colecciones son de hecho asociaciones uno-a-muchos con <literal>inverse=\"true\"</literal>. Para estas asociaciones, la actualización es manejada por el extremo muchos-a-uno de la asociación, y las consideraciones de este tipo sobre el rendimiento de actualización de colecciones simplemente no se aplican."
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr "Los Bags y las listas son las colecciones inversas más eficientes"
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr "Justo antes que tires a la zanja los bags para siempre, hay un caso en particular en el que los bags son muchos más eficientes que los conjuntos. Para una colección con <literal>inverse=\"true\"</literal> (el idioma estándar de relaciones uno-a-muchos bidireccionales, por ejemplo) ¡podemos añadir elementos a un bag o lista sin necesidad de inicializar (fetch) los elementos del bag! Esto se debe a que <literal>Collection.add()</literal> o <literal>Collection.addAll()</literal> siempre deben devolver true para un bag o <literal>List</literal> (no como un <literal>Set</literal>). Esto puede hacer el siguiente código común mucho más rápido."
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ " Child c = new Child();\n"
+ " c.setParent(p);\n"
+ " p.getChildren().add(c); //no need to fetch the collection!\n"
+ " sess.flush();]]>"
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr "Borrado de un solo tiro"
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr "Ocasionalmente, borrar los elementos de una colección uno a uno puede ser extremadamente ineficiente. Hibernate no es completamente estúpido, de modo que sabe no hacer eso, en el caso de una colección nueva-vacía (si has llamado a <literal>list.clear()</literal>, por ejemplo). En este caso, Hibernate publicará una sola <literal>DELETE</literal>, ¡y listo!"
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr "Supón que añadimos un solo elemento a una colección de tamaño veinte y luego quitamos dos elementos. Hibernate publicará una sentencia <literal>INSERT</literal> y dos sentencias <literal>DELETE</literal> (a menos que la colección sea un bag). Esto es ciertamente deseable."
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr "Sin embargo, supón que quitamos dieciocho elementos, dejando dos y luego añadimos tres nuevos elementos. Hay dos formas posibles de proceder"
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr "borrar dieciocho filas una a una y luego insertar tres filas"
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr "quitar toda la colección (en un solo <literal>DELETE</literal> de SQL) e insertar todos los cinco elementos actuales (uno a uno)"
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr "Hibernate no es lo suficientemente inteligente para saber que la segunda opción es probablemente más rápida en este caso. (Y que sería probablemente indeseable para Hibernate ser tan inteligente; este comportamiento podría confundir a disparadores de base de datos, etc.)"
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr "Afortunadamente, puedes forzar este comportamiento (es decir, la segunda estrategia) en cualquier momento descartando (es decir, desreferenciando) la colección original y devolviendo una colección nuevamente instanciada con todos los elementos actuales. Esto puede ser muy útil y potente de vez en cuando."
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr "Por supuesto, el borrado-de-un-solo-tiro no se aplica a colecciones mapeadas <literal>inverse=\"true\"</literal>."
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr "Monitoreando el rendimiento"
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr "La optimización no es de mucho uso sin el monitoreo y el acceso a números de rendimiento. Hibernate provee un rango completo de figuras sobre sus operaciones internas. Las estadísticas en Hibernate están disponibles por <literal>SessionFactory</literal>."
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr "Monitoreando una SessionFactory"
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr "Puedes acceder a las métricas de <literal>SessionFactory</literal> de dos formas. Tu primera opción es llamar a <literal>sessionFactory.getStatistics()</literal> y leer o mostrar por pantalla la <literal>Statistics</literal> por ti mismo."
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr "Hibernate puede también usar JMX para publicar las métricas si habilitas el MBean <literal>StatisticsService</literal>. Puede habilitar un solo MBean para todas tus <literal>SessionFactory</literal> o una por fábrica. Mira el siguiente código para ejemplos de configuración minimalistas:"
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr "POR HACER: Esto no tiene sentido: En el primer caso, recuperamos y usamos el MBean directamente. En el segundo, debemos proporcionar el nombre JNDI en el que se guarda la fábrica de sesiones antes de usarlo. Usa <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr "Puedes (des)activar el monitoreo de una <literal>SessionFactory</literal>"
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr "en tiempo de configuración, establece <literal>hibernate.generate_statistics</literal> a <literal>false</literal>"
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr "en tiempo de ejecución: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> o <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr "Las estadísticas pueden ser reajustadas programáticamente usando el método <literal>clear()</literal>. Puede enviarse un resumen a un logger (nivel info) usando el método <literal>logSummary()</literal>."
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr "Métricas"
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr "Hibernate provee un número de métricas, desde información muy básica a la especializada sólo relevante en ciertos escenarios. Todos los contadores disponibles se describen en la API de la interface <literal>Statistics</literal>, en tres categorías:"
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr "Métricas relacionadas al uso general de <literal>Session</literal> usage, tales como número de sesiones abiertas, conexiones JDBC recuperadas, etc,"
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr "Métricas relacionadas a las entidades, colecciones, consultas, y cachés como un todo. (también conocidas como métricas globales)."
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr "Métricas detalladas relacionadas a una entidad, colección, consulta o región de caché en particular."
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr "Por ejemplo, puedes comprobar el acceso, pérdida, y radio de colocación de entidades, colecciones y consultas en el caché, y el tiempo promedio que necesita una consulta. Ten en cuenta que el número de milisegundos está sujeto a aproximación en Java. Hibernate está pegado a la precisión de la JVM, en algunas plataformas esto podría incuso ser tener sólo una exactitud de 10 segundos."
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr "Se usan getters simples para acceder a las métricas globales (es decir, no pegadas a una entidad, colección, región de caché, etc, en particular). Puedes acceder a las métricas de una entidad, colección, región de caché en particular a través de su nombre, y a través de su representación HQL o SQL para las consultas. Por favor refiérete al Javadoc de la API de <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, y <literal>QueryStatistics</literal> para más información. El siguiente código muestra un ejemplo sencillo:"
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr "Para trabajar sobre todas las entidades, colecciones, consultas y regiones de cachés, puedes recuperar la lista de nombres de entidades, colecciones, consultas y regiones de cachés con los siguientes métodos: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, y <literal>getSecondLevelCacheRegionNames()</literal>."
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr ""
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr ""
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr ""
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr ""
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr ""
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr ""
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,625 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr "Clases Persistentes"
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr "Clases presistentes son clases en una aplicación que implementan las entidades del problema de negocio (por ejemplo, Customer y Order en una aplicación de comercio electrónico). No todas las instancias de una clase persistente se considera que estén en el estado persistente, una instancia puede en cambio ser transitoria o estar separada."
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr "Hibernate funciona mejor si las clases siguen algunas simples reglas, también conocidas como el modelo de programación de Viejas Clases Java Planas (Plain Old Java Object o POJO). Sin embargo, ninguna de estas reglas son requerimientos rígidos. En cambio, Hibernate3 asume muy poco acerca de la naturaleza de tus objetos persistentes. Puedes expresar un modelo de dominio en otras formas: usando árboles de instancias de <literal>Map</literal>, por ejemplo."
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr "Un ejemplo simple de POJO"
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr "La mayoría de aplicaciones Java requieren una clase representando felinos."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr "Aquí hay cuatro reglas principales a seguir:"
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr "Implementa un constructor sin argumentos"
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr "<literal>Cat</literal> tiene un contructor sin argumentos. Todas las clases persistentes deben tener un constructor por defecto (que puede no ser público) de modo que Hibernate pueda instanciarlas usando <literal>Constructor.newInstance()</literal>. Recomendamos fuertemente tener un constructor por defecto con al menos visibilidad de <emphasis>package</emphasis> para la generación de proxies en tiempo de ejecución en Hibernate."
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr "Provee una propiedad identificadora (opcional)"
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr "<literal>Cat</literal> tiene una propiedad llamada <literal>id</literal>. Esta propiedad mapea a la columna clave primaria de la tabla de base de datos. La propiedad podría llamarse cualquierCosa, y su tipo podría haber sido cualquier tipo primitivo, cualquier tipo de \"envoltura\" primitivo, <literal>java.lang.String</literal> o <literal>java.util.Date</literal>. (Si tu tabla de base de datos heredada tiene claves compuestas, puedes incluso usar una clase definida por el usuario con propiedades de estos tipos, ver la sección sobre identificadores compuestos luego.)"
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr "La propiedad identificadora es estrictamente opcional. Puedes olvidarla y dejar que Hibernate siga internamente la pista de los identificadores del objeto. Sin embargo, no recomendamos esto."
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr "De hecho, alguna funcionalidad está disponible sólo para clases que declaran una propiedad identificadora:"
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr "Reasociación transitiva de objetos separados (actualizaciones o fusiones en cascada) - ver"
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr "Session.saveOrUpdate()"
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr "Session.merge()"
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr "Recomendamos que declares propiedades identificadoras nombradas-consistentemente en clases persistentes. Mas aún, recomendamos que uses un tipo nulable (es decir, no primitivo)."
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr "Prefiere las clases no finales (opcional)"
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr "Un aspecto central de Hibernate, <emphasis>proxies</emphasis>, depende de que las clases persistentes sean ya no finales, o sean ya la implementación de una interface que declare todos los métodos públicos."
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr "Puedes persistir con Hibernate clases <literal>final</literal> que no implementen una interface, pero no serás capaz de usar proxies para recuperación perezosa de asociaciones, lo que limitará tus opciones para afinar el rendimiento."
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr "Debes también evitar declarar métodos <literal>public final</literal> en clases non-final. Si quieres usar una clase con un método <literal>public final</literal>, debes deshabilitar explícitamente el uso de proxies estableciendo <literal>lazy=\"false\"</literal>."
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr "Declara métodos de acceso y modificación para los campos persistentes (opcional)"
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr "<literal>Cat</literal> declara métodos de acceso para todos sus campos persistente. Muchas otras herramientas ORM persisten directamente variables de instancia. Creemos que es mejor proveer una indirección entre el esquema relacional y las estructuras internas de la clase. Por defecto, Hibernate persiste propiedades del estilo JavaBeans, y reconoce nombres de método de la forma <literal>getFoo</literal>, <literal>isFoo</literal> y <literal>setFoo</literal>. Puedes cambiar a acceso directo a campos para propiedades en particular, de ser necesario."
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr "Las propiedades <emphasis>no</emphasis> necesitan ser declaradas públicas. Hibernate puede persistir una propiedad con un par get / set <literal>protected</literal> o <literal>private</literal>."
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr "Implementando herencia"
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr "Una subclase puede a su vez observar la primera y segunda regla. Hereda su propiedad identificadora de la superclase, <literal>Cat</literal>."
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr "Implementando <literal>equals()</literal> y <literal>hashCode()</literal>"
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr "Tienes que sobrescribir los métodos <literal>equals()</literal> y <literal>hashCode()</literal> si :"
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr "piensas poner instancias de clases persistentes en un <literal>Set</literal> (la forma recomendada de representar asociaciones multivaluadas) <emphasis>y</emphasis>"
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr "piensas usar reasociación de instancias separadas."
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr "Hibernate garantiza la equivalencia de identidad persistente (fila de base de datos) y identidad Java sólo dentro del ámbito de una sesión en particular. De modo que en el momento que mezclamos instancias recuperadas en sesiones diferentes, debemos implementar <literal>equals()</literal> y <literal>hashCode()</literal> si deseamos tener una semántica significativa de <literal>Set</literal>s."
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr "La forma más obvia es implementar <literal>equals()</literal>/<literal>hashCode()</literal> comparando el valor identificador de ambos objetos. Si el valor es el mismo, ambos deben ser la misma fila de base de datos, por lo tanto son iguales (si ambos son agregados a un <literal>Set</literal>, sólo tendremos un elemento en el <literal>Set</literal>). Desafortunadamente, no podemos usar este enfoque con identificadores generados! Hibernate sólo asignará valores identificadores a objetos que son persistentes, una instancia recién creada no tendrá ningún valor identificador! Además, si una instancia no está salvada y está actualmente en un <literal>Set</literal>, salvarla asignará un valor identificador al objeto. Si <literal>equals()</literal> and <literal>hashCode()</literal> están basados en el valor identificador, el código hash podría cambiar, rompiendo el contrato de!
<literal>Set</literal>. Ver el sitio web de Hibernate para una discusión completa de este problema. Observa que esto no es una incidencia de Hibernate, sino la semántica normal de Java de identidad de objeto e igualdad."
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr "Recomendamos implementar <literal>equals()</literal> y <literal>hashCode()</literal> usando <emphasis>igualdad de clave de negocio (Business key equality)</emphasis>. Igualdad de clave de negocio significa que el método <literal>equals()</literal> compara sólo las propiedades que forman la clave de negocio, una clave que podría identificar nuestra instancia en el mundo real (una clave candidata <emphasis>natural</emphasis>):"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr "Nota que una clave de negocio no tiene que ser tan sólida como una clave primaria candidata de base de datos (ver <xref linkend=\"transactions-basics-identity\"/>). Las propiedades inmutables o únicas son usualmente buenas candidatas para una clave de negocio."
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr "Modelos dinámicos"
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr "Ten en cuenta que las siguientes funcionalidades están consideradas actualmente experimentales y pueden cambiar en el futuro cercano."
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr "Las entidades persistentes no necesariamente tienen que estar representadas como clases POJO o como objetos JavaBean en tiempo de ejecución. Hibernate soporta además modelos dinámicos (usando <literal>Map</literal>s de <literal>Map</literal>s en tiempo de ejecución) y la representación de entidades como árboles de DOM4J. Con este enfoque no escribes clases persistentes, sólo ficheros de mapeo."
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr "Por defecto, Hibernate funciona en modo POJO normal. Puedes establecer una representación de entidad por defecto para una <literal>SessionFactory</literal> en particular usando la opción de configuración <literal>default_entity_mode</literal> (ver <xref linkend=\"configuration-optional-properties\"/>)."
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr "Los siguientes ejemplos demuestran la representación usando <literal>Map</literal>s. Primero, en el fichero de mapeo, tiene que declararse un <literal>entity-name</literal> en vez de (o como agregado a) un nombre de clase:"
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr "Ten en cuenta que aunque las asociaciones se declaran usando nombres de clase objetivo, el tipo objetivo de una asociación puede ser además una entidad dinámica en vez de un POJO."
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr "Después de establecer el modo de entidad por defecto a <literal>dynamic-map</literal> para la <literal>SessionFactory</literal>, podemos trabajar en tiempo de ejecución con <literal>Map</literal>s de <literal>Map</literal>s:"
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr "Las ventajas de un mapeo dinámico es rápido tiempo de ciclo de prototipado sin la necesidad de implementación de clases de entidad. Sin embargo, pierdes chequeo de tipos en tiempo de compilación y muy probablemente tratarás con muchas excepciones en tiempo de ejecución. Gracias al mapeo de Hibernate, el esquema de base de datos puede estar facilmente sano y normalizado, permitiendo agregar una implementación apropiada del modelo de dominio más tarde."
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr "Los modos de representación de entidad pueden ser establecidos por <literal>Session</literal>:"
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr "Por favor, ten en cuenta que la llamada a <literal>getSession()</literal> usando un <literal>EntityMode</literal> está en la API de <literal>Session</literal>, no en la de <literal>SessionFactory</literal>. De esta forma, la nueva <literal>Session</literal> comparte la conexión JDBC, transacción y otra información de contexto. Esto significa que no tienes que llamar a <literal>flush()</literal> ni a <literal>close()</literal> en la <literal>Session</literal> secundaria, y tembién dejar el manejo de la transacción y de la conexión a la unidad de trabajo primaria."
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr "Puede encontrarse más información sobre las capacidades de representación XML en <xref linkend=\"xml\"/>."
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr "PORHACER: Documentar el framework de extensiones del usuario en los paquetes de propiedad y proxies."
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr ""
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr ""
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr "Prefacio"
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "Trabajar con software orientado a objetos y una base de datos relacional puede ser incómodo y consumir tiempo en los entornos de empresa de hoy. Hibernate es una herramienta de mapeo objeto/relacional para entornos Java. El término mapeo objeto/relacional (MOR) hace referencia a la técnica de mapear una representación de datos desde un modelo de objetos a un modelo de datos relacional con un esquema basado en SQL."
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Hibernate no sólo se encarga de mapear de clases Java a tablas de base de datos (y de tipos de datos de Java a tipos de datos SQL), sino que también provee facilidades de consulta y recuperación de datos y puede reducir significativamente el tiempo de desarrollo que de otra forma se gasta en el manejo de los datos en SQL y JDBC."
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "La meta de Hibernate es relevar al desarrollador del 95 por ciento de las tareas comunes relacionadas a la programación de la persistencia de los datos. Hibernate puede no ser la mejor solución para aplicaciones que usan solamente procedimientos almacenados para implementar la lógica de negocio en la base de datos, es mas útil con modelos de dominio orientados a objetos y lógica de negocio en middle-tier basada en Java. Sin embargo, Hibernate ciertamente puede ayudarte a quitar o encapsular código SQL específico de vendedor y ayudará con la tarea común de traducción de resultados desde una representación tabular a un grafo de objetos."
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "Si eres nuevo en Hibernate y lo del Mapeo Objeto/Relacional o incluso en Java, sigue por favor estos pasos:"
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "Lee <xref linkend=\"quickstart\"/> para un tutorial de 30 minutos, usando Tomcat."
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr "Lee <xref linkend=\"architecture\"/> para entender los entornos en los que puede ser usado Hibernate."
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "Dale una mirada al directorio <literal>eg/</literal> en la distribución de Hibernate, contiene una aplicación independiente simple. Copia tu driver JDBC al directorio <literal>lib/</literal> y edita <literal>etc/hibernate.properties</literal>, especificando los valores correctos para tu base de datos. Desde línea de comandos en el directorio de la distribución, tipea <literal>ant eg</literal> (usando Ant), o bajo Windows, tipea <literal>build eg</literal>."
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "Usa esta documentación de referencia como tu fuente de información primaria. Ten en consideración leer <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) si necesitas mas ayuda con el diseño de aplicaciones o si prefieres un tutorial paso a paso. Visita también http://caveatemptor.hibernate.org y descarga la aplicación de ejemplo para Java Persistence with Hibernate."
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr "Los FAQs son respondidos en el sitio web de Hibernate."
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr "En el sitio web de Hibernate hay enlaces a demos de terceros, ejemplos y tutoriales."
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "El Area de Comunidad en el sitio web de Hibernate es una buena fuente de patrones de diseño y varias soluciones de integración (Tomcat, JBoss, Struts, EJB, etc.)."
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "Si tienes preguntas, usa el foro de usuarios enlazado en el sitio web de Hibernate. También proveemos un sistema de seguimiento JIRA para reportes de defectos y peticiones de nuevas características. Si estas interesado en el desarrollo de Hibernate, únete a la lista de correo de desarrolladores. Si estas interesado en traducir esta documentación a tu lenguaje, contáctanos en la lista de correo de desarrolladores."
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "A través de JBoss Inc. (see http://www.hibernate.org/SupportTraining/) hay disponibilidad de soporte comercial de desarrollo, soporte de producción y entrenamiento en Hibernate. Hibernate es un proyecto de la suite de productos de código abierto JBoss Professional."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,672 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr "Consultas por Criterios"
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr "Acompaña a Hibernate una API de consultas por criterios intuitiva y extensible."
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr "Creando una instancia de <literal>Criteria</literal>"
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr "La interface <literal>org.hibernate.Criteria</literal> representa una consulta contra una clase persistente en particular. La <literal>Session</literal> es una fábrica de instancias de <literal>Criteria</literal>."
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr "Estrechando el conjunto resultado"
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr "Un criterio individual de consulta es una instancia de la interface <literal>org.hibernate.criterion.Criterion</literal>. La clase <literal>org.hibernate.criterion.Restrictions</literal> define métodos de fábrica para obtener ciertos tipos prefabricados de <literal>Criterion</literal>."
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr "Las restricciones pueden ser agrupadas lógicamente."
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr "Hay un gran rango de tipos de criterio prefabricados (subclases de <literal>Restrictions</literal>), pero uno que es especialmente útil te deja especificar SQL directamente."
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sql(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr "El sitio <literal>{alias}</literal> será remplazado por el alias de fila de la entidad consultada."
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr "Un enfoque alternativo para obtener un criterio es tomarlo de una instancia de <literal>Property</literal>. Puedes crear una <literal>Property</literal> llamando a <literal>Property.forName()</literal>."
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr "Ordenando los resultados"
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr "Puedes ordenar los resultados usando <literal>org.hibernate.criterion.Order</literal>."
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:81
+msgid "Associations"
+msgstr "Asociaciones"
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr "Puedes especificar fácilmente restricciones sobre las entidades relacionadas al navegar asociaciones usando <literal>createCriteria()</literal>."
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .list();]]>"
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr "nota que el segundo <literal>createCriteria()</literal> devuelve una nueva instancia de <literal>Criteria</literal>, que hace referencia a los elementos de la colección <literal>kittens</literal>."
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr "La siguiente forma alternativa es útil en ciertas circunstancias."
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr "(<literal>createAlias()</literal> no crea una nueva instancia de <literal>Criteria</literal>.)"
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr "¡Observa que las colecciones de gatitos tenidas por las instancias de <literal>Cat</literal> devueltas por las dos consultas previas <emphasis>no</emphasis> están prefiltradas por los criterios! Si deseas recuperar sólo los gatitos que emparejen los criterios, debes usar <literal>returnMaps()</literal>."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .returnMaps()\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr "Recuperación dinámica de asociaciones"
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr "Puedes especificar la semántica de recuperación de asociaciones en tiempo de ejecución usando <literal>setFetchMode()</literal>."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "Esta consulta recuperará tanto <literal>mate</literal> como <literal>kittens</literal> por unión exterior (outer join). Ver <xref linkend=\"performance-fetching\"/> para más información."
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr "Consultas por ejemplos"
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr "La clase <literal>org.hibernate.criterion.Example</literal> te permite construir un criterio de consulta a partir de una instancia dada."
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr "Las propiedades de versión, los identificadores y las asociaciones son ignorados. Por defecto, las propiedades valuadas a nulo son excluídas."
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr "Puedes ajustar cómo se aplica el <literal>Example</literal>."
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr "Puedes incluso usar ejemplos para colocar criterios sobre objetos asociados."
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr "Proyecciones, agregación y agrupamiento"
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr "La clase <literal>org.hibernate.criterion.Projections</literal> es una fábrica de instancias de <literal>Projection</literal>. Aplicamos una proyección a una consulta llamando a <literal>setProjection()</literal>."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr "No es necesario ningún \"group by\" explícito en una consulta por criterios. Ciertos tipos de proyecciones son definidos para ser <emphasis>proyecciones agrupadas</emphasis>, que además aparecen en la cláusula SQL <literal>group by</literal>."
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr "Puede opcionalmente asignarse un alias a una proyección, de modo que el valor proyectado pueda ser referido en restricciones u ordenamientos. Aquí hay dos formas diferentes de hacer esto:"
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr "Los métodos <literal>alias()</literal> y <literal>as()</literal> simplemente envuelven una instancia de proyección en otra instancia de <literal>Projection</literal> con alias. Como un atajo, puedes asignar un alias cuando agregas la proyección a una lista de proyecciones:"
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr "Puedes también usar <literal>Property.forName()</literal> para expresar proyecciones:"
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr "Consultas y subconsultas separadas"
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr "La clase <literal>DetachedCriteria</literal> te deja crear una consulta fuera del ámbito de una sesión, y entonces ejecutarla luego usando alguna <literal>Session</literal> arbitraria."
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr "También una <literal>DetachedCriteria</literal> puede usarse para expresar una subconsulta. Las instancias de Criterion implicando subconsultas pueden obtenerse vía <literal>Subqueries</literal> o <literal>Property</literal>."
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr "Incluso son posibles las subconsultas correlacionadas:"
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr "Consultas por identificador natural"
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr "Para la mayoría de consultas, incluyendo las consultas por criterios, el caché de consulta no es muy eficiente, debido a que la invalidación del caché de consulta ocurre demasiado frecuentemente. Sin embargo, hay un tipo especial de consulta donde podemos optimizar el algoritmo de invalidación de caché: búsquedas por una clave natural constante. En algunas aplicaciones, este tipo de consulta, ocurre frecuentemente. La API de criterios brinda especial provisión para este caso de uso."
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr "Primero, debes mapear la clave natural de tu entidad usando <literal><natural-id></literal>, y habilitar el uso del caché de segundo nivel."
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr "Nota que esta funcionalidad no está pensada para uso con entidades con claves naturales <emphasis>mutable</emphasis>."
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr "Seguido, habilita el caché de consulta de Hibernate."
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr "Ahora, <literal>Restrictions.naturalId()</literal> nos permite hacer uso de el algoritmo de caché más eficiente."
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1510 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr "HQL: El Lenguaje de Consulta de Hibernate"
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr "Hibernate está equipado con un lenguaje de consulta extremadamente potente que (intencionalmente en absoluto) se parece muchísimo a SQL. Pero no te engañes por la sintaxis; HQL es completamente orientado a objetos, entendiendo nociones como herencia, polimorfismo y asociación."
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr "Sensibilidad a Mayúsculas"
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr "Las consultas son insensibles a mayúsculas, excepto para nombres de clases Java y propiedades. De modo que <literal>SeLeCT</literal> es lo mismo que <literal>sELEct</literal> e igual a <literal>SELECT</literal>, pero <literal>org.hibernate.eg.FOO</literal> no lo es a <literal>org.hibernate.eg.Foo</literal> y <literal>foo.barSet</literal> no es igual a <literal>foo.BARSET</literal>."
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr "Este manual usa palabras clave HQL en minúsculas. Algunos usuarios encuentran las consultas con palabras clave en mayúsculas más leíbles, pero encontramos esta convención fea cuando se encaja en código Java."
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr "La cláusula from"
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr "La consulta más simple posible de Hibernate es de la forma:"
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr "<![CDATA[from eg.Cat]]>"
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr "que simplemente devuelve todas las instancias de la clase <literal>eg.Cat</literal>. Usualmente no necesitamos cualificar el nombre de la clase, ya que <literal>auto-import</literal> está por defecto. De modo que casi siempre escribimos solamente:"
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr "<![CDATA[from Cat]]>"
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr "La mayoría del tiempo, necesitarás asignar un <emphasis>alias</emphasis>, ya que querrás referirte al <literal>Cat</literal> en otras partes de la consulta."
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr "Esta consulta asigna el alias <literal>cat</literal> a las instancias de <literal>Cat</literal>, de modo que podríamos usar ese alias luego en la consulta. La palabra clave <literal>as</literal> es opcional; también podríamos escribir:"
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr "<![CDATA[from Cat cat]]>"
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr "Pueden aparecer múltiples clases, resultando en un producto cartesiano o unión \"cruzada\" (cross join)."
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr "<![CDATA[from Formula, Parameter]]>"
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr "<![CDATA[from Formula as form, Parameter as param]]>"
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr "Se considera buena práctica el nombrar los alias de consulta usando una inicial en minúsculas, consistente con los estándares de nombrado de Java para variables locales (por ejemplo, <literal>domesticCat</literal>)."
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr "Asociaciones y uniones (joins)"
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr "Podemos también asignar aliases a entidades asociadas, e incluso a elementos de una colección de valores, usando una <literal>join</literal>."
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr "<![CDATA[from Formula form full join form.parameter param]]>"
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr "Los tipos de join soportados son prestados de ANSI SQL"
+
+#: index.docbook:103
+msgid "inner join"
+msgstr "inner join"
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr "left outer join"
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr "right outer join"
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr "<literal>full join</literal> (no útil usualmente)"
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr "Las construcciones <literal>inner join</literal>, <literal>left outer join</literal> y <literal>right outer join</literal> pueden ser abreviadas."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr "Puedes proveer condiciones de unión extra usando la palabra clave <literal>with</literal> de HQL."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " left join cat.kittens as kitten \n"
+ " with kitten.bodyWeight > 10.0]]>"
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "En adición, un \"fetch\" join permite a las asociaciones o colecciones de valores ser inicializadas junto a sus objetos padres, usando una sola selección. Esto es particularmente útil en el case de una colección. Efectivamente sobrescribe el outer join y las declaraciones perezosas (lazy) del fichero de mapeo para asociaciones y colecciones. Ver <xref linkend=\"performance-fetching\"/> para más información."
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr "Usualmente a un fetch join no se necesita asignársele un alias, porque los objetos asociados no deben ser usados en la cláusula <literal>where</literal> (ni en cualquier otra cláusula). Además, los objetos asociados no son devueltos directamente en los resultados de consulta. En cambio, pueden ser accedidos vía el objeto padre. La única razón por la que necesitaríamos un alias es estamos uniendo recursivamente otra colección:"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr "Nota que la construcción <literal>fetch</literal> no puede usarse en consultas llamadas usando <literal>scroll()</literal> o <literal>iterate()</literal>. Ni debe usarse <literal>fetch</literal> junto con <literal>setMaxResults()</literal> o <literal>setFirstResult()</literal>. Tampoco puede usarse <literal>fetch</literal> junto a una condición <literal>with</literal> ad hoc. Es posible crear un producto cartesiano trayendo por join más de una colección en una colección, así que ten cuidado en este caso. Traer por join múltiples roles de colección también da a veces resultados inesperados para mapeos de bag, así que sé cuidadoso sobre cómo formular tus consultas en este caso. Finalmente, nota que <literal>full join fetch</literal> y <literal>right join fetch</literal> no son significativos."
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr "Si estás usando recuperación perezosa a nivel de propiedad (con instrumentación de bytecode), es posible forzar a Hibernate a traer las propiedades perezosas inmediatamente (en la primera consulta) usando <literal>fetch all properties</literal>."
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr "<![CDATA[from Document fetch all properties order by name]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr "La cláusula select"
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr "La cláusula <literal>select</literal> escoge qué objetos y propiedades devolver in el conjunto resultado de la consulta. Considera:"
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr ""
+ "<![CDATA[select mate \n"
+ "from Cat as cat \n"
+ " inner join cat.mate as mate]]>"
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr "La consulta seleccionará <literal>mate</literal>s de otros <literal>Cat</literal>s. Realmente, puedes expresar esta consulta en un forma más compacta como:"
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr "<![CDATA[select cat.mate from Cat cat]]>"
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr "Las consultas pueden devolver propiedades de cualquier tipo de valor incluyendo propiedades de tipo componente:"
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr "Las consultas pueden devolver múltiples objetos y/o propiedades como un array de tipo <literal>Object[]</literal>,"
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr ""
+ "<![CDATA[select mother, offspr, mate.name \n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr "o como una <literal>List</literal>,"
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr "o como un objeto real Java de tipo seguro,"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr "asumiendo que la clase <literal>Family</literal> tiene un constructor apropiado."
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr "Puedes asignar aliases para seleccionar expresiones usando <literal>as</literal>:"
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr "Esto es lo más útil cuando se usa junto con <literal>select new map</literal>:"
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr "Esta consulta devuelve un <literal>Map</literal> de aliases a valores seleccionados."
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr "Funciones de agregación"
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr "Las consultas HQL pueden incluso devolver resultados de funciones de agregación sobre propiedades:"
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr "Las funciones de agregación soportadas son"
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr "avg(...), sum(...), min(...), max(...)"
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr "count(*)"
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr "count(...), count(distinct ...), count(all...)"
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr "Puedes usar operadores aritméticos, concatenación, y funciones SQL reconocidas en la cláusula select:"
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr ""
+ "<![CDATA[select cat.weight + sum(kitten.weight) \n"
+ "from Cat cat \n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr "Las palabras clave <literal>distinct</literal> y <literal>all</literal> pueden ser usadas y tienen las misma semántica que en SQL."
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr "Consultas polimórficas"
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr "Una consulta como:"
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr "devuelve instancias no sólo de <literal>Cat</literal>, sino también de subclases como <literal>DomesticCat</literal>. Las consultas de Hibernate pueden mencionar <emphasis>cualquier</emphasis> clase o interface Java en la cláusula <literal>from</literal>. La consulta devolverá instancias de todas las clases persistentes que extiendan esa clase o implementen la interface. La siguiente consulta devolvería todos los objetos persistentes."
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr "<![CDATA[from java.lang.Object o]]>"
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr "La interface <literal>Named</literal> podría ser implementada por varias clases persistentes:"
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr "Nota que estas dos últimas consultas requerirán más de un <literal>SELECT</literal> SQL. Esto significa que la cláusula <literal>order by</literal> no ordenará correctamente todo el conjunto resultado. (Significa además que no puedes llamar estas consulta usando <literal>Query.scroll()</literal>.)"
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr "La cláusula where"
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr "La cláusula where te permite estrechar la lista de instancias devueltas. Si no existe ningún alias. puedes referirte a las propiedades por nombre:"
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr "<![CDATA[from Cat where name='Fritz']]>"
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr "Si existe un alias, usan un nombre cualificado de propiedad:"
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr ""
+ "<![CDATA[select foo \n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr "devolverá todas las instancias de <literal>Foo</literal> para las cuales exista una instancia de <literal>bar</literal> con una propiedad <literal>date</literal> igual a la propiedad <literal>startDate</literal> del <literal>Foo</literal>. Las expresiones de ruta compuestas hacen la cláusula <literal>where</literal> extremadamente potente. Considera:"
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr "Esta consulta se traduce en una consulta SQL con una unión de tabla (interna). Si fueses a escribir algo como"
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr ""
+ "<![CDATA[from Foo foo \n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr "terminarías con una consulta que requeriría cuatro uniones de tablas en SQL."
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr "El operador <literal>=</literal> puede ser usado para comparar no sólo propiedades, sino también instancias:"
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr ""
+ "<![CDATA[select cat, mate \n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr "La propiedad especial (en minúsculas) <literal>id</literal> puede ser usada para referenciar el identificador único de un objeto. (También puedes usar su nombre de propiedad.)"
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr "La segunda consulta es eficiente. ¡No se requiere ninguna unión de tablas!"
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr "También pueden ser usadas las propiedades de identificadores compuestos. Supón que <literal>Person</literal> tiene un identificador compuesto consistente en <literal>country</literal> y <literal>medicareNumber</literal>."
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU' \n"
+ " and person.id.medicareNumber = 123456]]>"
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU' \n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr "Una vez más, la segunda consulta no requiere ninguna unión de tablas."
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr "Asimismo, la propiedad especial <literal>class</literal> acccede al valor discriminador de una instancia en el caso de persistencia polimórfica. Un nombre de clase Java embebido en la cláusula where será traducido a su valor discriminador."
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr "Puedes también especificar propiedades de componentes o tipos compuestos de usuario (y de componentes de componentes, etc). Nunca intentes usar una expresión de ruta que termine en una propiedad de tipo componente (al contrario de una propiedad de un componente). Por ejemplo, si <literal>store.owner</literal> es una entidad con un componente <literal>address</literal>"
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+ "<![CDATA[store.owner.address.city // okay\n"
+ "store.owner.address // error!]]>"
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr "Un tipo \"any\" tiene las propiedades especiales <literal>id</literal> y <literal>class</literal>, permiténdonos expresar un join en la siguiente forma (donde <literal>AuditLog.item</literal> es una propiedad mapeada con <literal><any></literal>)."
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr ""
+ "<![CDATA[from AuditLog log, Payment payment \n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr "Nota que <literal>log.item.class</literal> y <literal>payment.class</literal> harían referencia a los valores de columnas de base de datos completamente diferentes en la consulta anterior."
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr "Expresiones"
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr "Las expresiones permitidas en la cláusula <literal>where</literal> incluyen la mayoría del tipo de cosas que podrías escribir en SQL:"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr "operadores matemáticos <literal>+, -, *, /</literal>"
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr "operadores de comparación binarios <literal>=, >=, <=, <>, !=, like</literal>"
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr "operadores lógicos <literal>and, or, not</literal>"
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr "Paréntesis <literal>( )</literal>, indicando agrupación"
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> y <literal>not member of</literal>"
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr "Caso \"simple\", <literal>case ... when ... then ... else ... end</literal>, y caso \"buscado\", <literal>case when ... then ... else ... end</literal>"
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr "concatenación de cadenas <literal>...||...</literal> o <literal>concat(...,...)</literal>"
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr "Cualquier función u operador definido por EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr "<literal>coalesce()</literal> y <literal>nullif()</literal>"
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr "<literal>str()</literal> para convertir valores numéricos o temporales a una cadena legible."
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr "<literal>cast(... as ...)</literal>, donde el segundo argumento es el nombre de un tipo Hibernate , y <literal>extract(... from ...)</literal> si <literal>cast()</literal> y <literal>extract()</literal> fuesen soportados por la base de datos subyacente."
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr "la función <literal>index()</literal> de HQL, que se aplica a alias de una colección indexada unida."
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr "funciones de HQL que tomen expresiones de ruta valuadas en colecciones: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, junto a las funciones especiales <literal>elements()</literal> and <literal>indices</literal> que pueden ser cuantificadas usando <literal>some, all, exists, any, in</literal>."
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr "Cualquier función escalar SQL soportada por la base de datos como <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr "parámetros posicionales JDBC <literal>?</literal>"
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr "parámetros con nombre <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr "literales SQL <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr "constantes Java <literal>public static final</literal> <literal>eg.Color.TABBY</literal>"
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr "<literal>in</literal> y <literal>between</literal> pueden usarse como sigue:"
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr "y pueden escribirse las formas negadas"
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr "Asimismo, <literal>is null</literal> y <literal>is not null</literal> pueden ser usadas para comprobar valores nulos."
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr "Los booleanos pueden ser fácilmente usados en expresiones declarando substituciones de consulta HQL en la configuración de Hibernate:"
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr "Esto remplazará las palabras clave <literal>true</literal> y <literal>false</literal> con los literales <literal>1</literal> y <literal>0</literal> en el SQL traducido de este HQL:"
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr "<![CDATA[from Cat cat where cat.alive = true]]>"
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr "Puedes comprobar el tamaño de una colección con la propiedad especial <literal>size</literal>, o la función especial <literal>size()</literal>."
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr "Para colecciones indexadas, puedes referirte a los índices máximo y mínimo usando las funciones <literal>minindex</literal> y <literal>maxindex</literal>. Similarmente, puedes referirte a los elementos máximo y mínimo de una colección de tipo básico usando las funciones <literal>minelement</literal> y <literal>maxelement</literal>."
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr "Las funciones SQL <literal>any, some, all, exists, in</literal> están soportadas cuando se les pasa el conjunto de elementos o índices de una colección (funciones <literal>elements</literal> y <literal>indices</literal>) o el resultado de una subconsulta (ver debajo)."
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr "Nota que estas construcciones - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - pueden ser usadas solamente en la cláusula where en Hibernate3."
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr "Los elementos de colecciones indexadas (arrays, listas, mapas) pueden ser referidos por índice (en una cláusula where solamente):"
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr "La expresión dentro de <literal>[]</literal> puede incluso ser una expresión aritmética."
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr "HQL provee además el función prefabricada <literal>index()</literal>, para elementos de una asociación uno-a-muchos o colección de valores."
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr ""
+ "<![CDATA[select item, index(item) from Order order \n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr "Pueden usarse las funciones SQL escalares soportadas por la base de datos subyacente"
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr "Si aún no estás convencido de todo esto, piensa cuánto más largo y menos leíble sería la siguiente consulta en SQL:"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr "<emphasis>Ayuda:</emphasis> algo como"
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr "La cláusula order by"
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr "La lista devuelta por una consulta puede ser ordenada por cualquier propiedad de una clase devuelta o componentes:"
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr "Los <literal>asc</literal> o <literal>desc</literal> opcionales indican ordenamiento ascendente o descendente respectivamente."
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr "La cláusula group by"
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr "Una consulta que devuelve valores agregados puede ser agrupada por cualquier propiedad de una clase devuelta o componentes:"
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat) \n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+ "<![CDATA[select foo.id, avg(name), max(name) \n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr "Se permite también una cláusula <literal>having</literal>."
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat) \n"
+ "from Cat cat\n"
+ "group by cat.color \n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr "Las funciones y funciones de agregación SQL están permitidas en las cláusulas <literal>having</literal> y <literal>order by</literal>, si están soportadas por la base de datos subyacente (por ejemplo, no en MySQL)."
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr "Nota que ni la cláusula <literal>group by</literal> ni la cláusula <literal>order by</literal> pueden contener expresiones aritméticas."
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr "Subconsultas"
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr "Para bases de datos que soportan subconsultas, Hibernate soporta subconsultas dentro de consultas. Una subconsulta debe ser encerrada entre paréntesis (frecuentemente por una llamada a una función de agregación SQL). Incluso se permiten subconsultas correlacionadas (subconsultas que hacen referencia a un alias en la consulta exterior)."
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr ""
+ "<![CDATA[from Cat as fatcat \n"
+ "where fatcat.weight > ( \n"
+ " select avg(cat.weight) from DomesticCat cat \n"
+ ")]]>"
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat \n"
+ "where cat.name = some ( \n"
+ " select name.nickName from Name as name \n"
+ ")]]>"
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ "where not exists ( \n"
+ " from Cat as mate where mate.mate = cat \n"
+ ")]]>"
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr ""
+ "<![CDATA[from DomesticCat as cat \n"
+ "where cat.name not in ( \n"
+ " select name.nickName from Name as name \n"
+ ")]]>"
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr "Para las subconsultas con más de una expresión en la lista de selección, puedes usar un constructor de tuplas:"
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ "where not ( cat.name, cat.color ) in ( \n"
+ " select cat.name, cat.color from DomesticCat cat \n"
+ ")]]>"
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr "Nota que en algunas bases de datos (pero no en Oracle o HSQL), puedes usar constructores de tuplar en otros contextos, por ejemplo al consultar componentes o tipos de usuario compuestos:"
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr "<![CDATA[from Person where name = ('Gavin', 'A', 'King')]]>"
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr "Que es equivalente a la más verborrágica:"
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr "<![CDATA[from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')]]>"
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr "Existen dos buenas razones por las cuales podrías no querer hacer este tipo de cosa: primero, no es completamente portable entre plataformas de base de datos; segundo, la consulta ahora es dependiente del orden de propiedades en el documento de mapeo."
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "Ejemplos de HQL"
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr "Las consultas de Hibernate pueden ser abolutamente potentes y complejas, De hecho, el poder del lenguaje de consulta es uno de los puntos principales de venta de Hibernate. He aquí algunos consultas de ejemplo muy similares a consultas que he usado en un proyecto reciente. ¡Nota que la mayoría de las consultas que escribirás som mucho más simples que estas!"
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "La siguiente consulta devuelve el order id, número de items y valor total de la orden para todas las ordenes inpagas de un cliente en particular y valor total mínimo dados, ordenando los resultados por valor total. Al determinar los precios, usa el catálogo actual. La consulta SQL resultante, contra las tablas <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tiene cuatro joins interiores y una subselect (no correlacionada)."
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate \n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr "¡Qué monstruo! Realmente, en la vida real, no estoy muy afilado en subconsultas, de modo que mi consulta fue realmente algo como esto:"
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr "La próxima consulta cuenta el número de pagos en cada estado, excluyendo todos los pagos en el estado <literal>AWAITING_APPROVAL</literal> donde el estado más reciente fue hecho por el usuario actual. Se traduce en una consulta SQL con dos joins interiores y una subselect correlacionada contra las tablas <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> y <literal>PAYMENT_STATUS_CHANGE</literal>."
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr ""
+ "<![CDATA[select count(payment), status.name \n"
+ "from Payment as payment \n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = ( \n"
+ " select max(change.timeStamp) \n"
+ " from PaymentStatusChange change \n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr "Si hubiese mapeado la colección <literal>statusChanges</literal> como una lista, en vez de un conjunto, la consulta habría sido mucho más simple de escribir."
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+ "<![CDATA[select count(payment), status.name \n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr "La próxima consulta usa la función <literal>isNull()</literal> de MS SQL Server para devolver todas las cuentas y pagos inpagos de la organización a la que pertenece el usuario actual. Se traduce en una consulta SQL con tres joins interiores, un join exterior y una subconsulta contra las tablas <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> y <literal>ORG_USER</literal>."
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr "Para algunas bases de datos, necesitaríamos eliminar la subselect (correlacionada)."
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr "Sentencias UPDATE y DELETE masivas"
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr "HQL soporta ahora sentencias UPDATE y DELETE en HQL. Ver <xref linkend=\"batch-direct\"/> para detalles."
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr "Consejos y Trucos"
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "Puedes contar el número de resultados de una consulta sin devolverlos realmente:"
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "Para ordenar un resultado por el tamaño de una colección, usa la siguiente consulta:"
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr \n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr "Si tu base de datos soporta subselects, puedes colocar una condición sobre el tamaño de selección en la cláusula where de tu consulta:"
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr "Si tu base de datos no soporta subselects, usa la siguiente consulta:"
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr "Como esta solución no puede devolver un <literal>User</literal> con cero mensajes debido a la unión interior, la siguiente forma es también útil:"
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr "Las propiedades de un JavaBean pueden ser ligadas al parámetros de consulta con nombre:"
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr "Las colecciones son paginables usando la interface <literal>Query</literal> con un filtro:"
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr "Los elementos de colección pueden ser ordenados o agrupados usando un filtro de consulta:"
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr "Puedes hallar el tamaño de una colección sin inicializarla:"
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr ""
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr ""
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr ""
+
+#: index.docbook:985
+msgid "Components"
+msgstr ""
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr ""
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr ""
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr ""
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr ""
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr ""
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr ""
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr ""
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr ""
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr ""
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,990 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr "SQL Nativo"
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr "Puedes también expresar consultas en el dialecto SQL nativo de tu base de datos. Esto es útil si quieres utilizar aspectos específicos de base de datos tal como consejos (hints) de consulta o la palabra clave <literal>CONNECT</literal> en Oracle. Provee además una clara ruta de migración desde una aplicación basada en SQL/JDBC directo a Hibernate."
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr "Hibernate3 te permite especificar SQL escrito a mano (incluyendo procedimientos almacenados) para todas las operaciones de creación, actualización, borrado y carga."
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr "Creando una <literal>Query</literal> de SQL nativo"
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr "Las consultas SQL se controlan por medio de la interface <literal>SQLQuery</literal>, que se obtiene llamando a <literal>Session.createSQLQuery()</literal>."
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr ""
+ "<![CDATA[List cats = sess.createSQLQuery(\"select {cat.*} from cats cat\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr "Esta consulta especificada:"
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr "la cadena de consulta SQL, con un lugar para que Hibernate inyecte los alias de columnas"
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr "la entidad devuelta por la consulta, y sus alias de tablas SQL"
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr "El método <literal>addEntity()</literal> asocia alias de tablas SQL con clases de entidad, y determina la forma del conjunto resultado de la consulta."
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr "El método <literal>addJoin()</literal> puede ser usado para cargar asociaciones a otras entidades y colecciones."
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"kitten\", \"cat.kittens\")\n"
+ " .list();]]>"
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr "Una consulta SQL nativa podría devolver un valor escalar simple o una combinación de escalares y entidades."
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr ""
+ "<![CDATA[Double max = (Double) sess.createSQLQuery(\"select max(cat.weight) as maxWeight from cats cat\")\n"
+ " .addScalar(\"maxWeight\", Hibernate.DOUBLE);\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr "Alias y referencias de propiedad"
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr "La notación <literal>{cat.*}</literal> usada arriba es un atajo para \"todas las propiedades\". Alternativamente, puedes listar las columnas explícitamente, pero incluso en este caso dejamos que Hibernate inyecte los alias de columnas SQL para cada propiedad. El lugar para un alias de columna es sólo el nombre de propiedad cualificado por el alias de la tabla. En el siguiente ejemplo, recuperamos <literal>Cat</literal>s de una tabla diferente (<literal>cat_log</literal>) a una declarada en los metadatos de mapeo. Nota que podríamos incluso usar los alias de propiedad en la cláusula where si quisieramos."
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr "La sintáxis <literal>{}</literal> <emphasis>no</emphasis> es requerida para consultas con nombre. Ver"
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr ""
+ "<![CDATA[String sql = \"select cat.originalId as {cat.id}, \" +\n"
+ " \"cat.mateid as {cat.mate}, cat.sex as {cat.sex}, \" +\n"
+ " \"cat.weight*10 as {cat.weight}, cat.name as {cat.name} \" +\n"
+ " \"from cat_log cat where {cat.mate} = :catId\"\n"
+ " \n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .setLong(\"catId\", catId)\n"
+ " .list();]]>"
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr "<emphasis>Nota:</emphasis> si listas cada propiedad explícitamente, ¡debes incluir todas las propiedades de la clase <emphasis>y sus subclases</emphasis>!"
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr "Consultas SQL con nombre"
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr "Las consultas SQL con nombre pueden definirse en el documento de mapeo y llamadas exactamente en la misma forma en que a una consulta HQL con nombre. En este caso, <emphasis>no</emphasis> necesitamos llamar a <literal>addEntity()</literal>."
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person \n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person \n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr "Una consulta SQL con nombre puede devolver un valor escalar. Debes especificar el alias de columna y tipo Hibernate usando el elementp <literal><return-scalar></literal>:"
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr "Usando return-property para especificar explícitamente nombres de columna/alias"
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr "Con <literal><return-property></literal> puedes decirle explícitamente a Hibernate qué alias de columna usar, en vez de usar la sintáxis <literal>{}</literal> para dejar que Hibernate inyecte sus propios alias."
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr "<literal><return-property></literal> también trabaja con múltiples columnas. Esto resuelve una limitación de la sintáxis <literal>{}</literal>, la cual no puede permitir un control fino de propiedades multi-columna."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\"> \n"
+ " <return-property name=\"salary\"> \n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/> \n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer}, \n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr "Nota que en este ejemplo hemos usado <literal><return-property></literal> en combinación con la sintáxis <literal>{}</literal> para inyección, permitiendo a los usuarios elejir cómo quieren referirse a las columnas y propiedades."
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr "Si tu mapeo tiene un discriminador debes usar <literal><return-discriminator></literal> para especificar la columna discriminadora."
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr "Usando procedimientos almacenados para consultar"
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr "Hibernate3 introduce soporte para consultas vía procedimientos almacenados. Los procedimientos almacenados deben devolver un conjunto resultado como el primer parámetro de salida para ser capaces de funcionar con Hibernate. Un ejemplo de uno procedimiento almacenado en Oracle 9 o superior es así:"
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments \n"
+ " RETURN SYS_REFCURSOR \n"
+ "AS \n"
+ " st_cursor SYS_REFCURSOR; \n"
+ "BEGIN \n"
+ " OPEN st_cursor FOR \n"
+ " SELECT EMPLOYEE, EMPLOYER, \n"
+ " STARTDATE, ENDDATE, \n"
+ " REGIONCODE, EID, VALUE, CURRENCY \n"
+ " FROM EMPLOYMENT; \n"
+ " RETURN st_cursor; \n"
+ " END;]]>"
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr "Para usar esta consulta en Hibernate necesitas mapearla por medio de una consulta con nombre."
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/> \n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/> \n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/> \n"
+ " <return-property name=\"id\" column=\"EID\"/> \n"
+ " <return-property name=\"salary\"> \n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/> \n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr "Nota que los procedimientos almacenados sólo devuelven escalares y entidades. No están soportados <literal><return-join></literal> y <literal><load-collection></literal>."
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr "Reglas/limitaciones para usar procedimientos almacenados"
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr "Para usar procedimientos almacenados con Hibernate los procedimientos tienen que seguir algunas reglas. Si no siguen esas reglas no son usables por Hibernate. Si aún quisieras usar estos procedimientos tendrías que ejecutarlos por medio de <literal>session.connection()</literal>. Las reglas son diferentes para cada base de datos, ya que los vendedores de base de datos tienen diferentes semánticas/sintáxis de procedimientos almacenados."
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr "Para Oracle se aplican las siguientes reglas:"
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr "El procedimiento debe devolver un conjunto resultado. Esto se hace devolviendo un <literal>SYS_REFCURSOR</literal> en Oracle 9 o 10. En Oracle necesitas definir un tipo <literal>REF CURSOR</literal>."
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr "La forma recomendada es <literal>{ ? = call procName(<parameters>) }</literal> o <literal>{ ? = call procName }</literal> (esto es más una regla de Oracle que una regla de Hibernate)."
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr "Para Sybase o MS SQL server se aplican las siguientes reglas:"
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr "El procedimiento debe devolver un conjunto resultado. Nota que ya que estos servidores pueden y devolverán múltiples conjuntos resultados y cuentas de actualización, Hibernate iterará los resultados y tomará el primer resultado que sea un conjunto resultado como su valor a devolver. Todo lo demás será descartado."
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr "Si habilitas <literal>SET NOCOUNT ON</literal> en tu procedimiento será probablemente más eficiente, pero esto no es un requerimiento."
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr "SQL personalizado para crear, actualizar y borrar"
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr "Hibernate3 puede usar sentencias SQL personalizadas para las operaciones de crear, actualizar y borrar. Los persistidores de clases y colecciones en Hibernate ya contienen un conjunto de cadenas generadas en tiempo de configuración (insertsql, deletesql, updatesql, etc.). Las etiquetas de mapeo <literal><sql-insert></literal>, <literal><sql-delete></literal>, y <literal><sql-update></literal> sobrescriben estas cadenas:"
+
+#: index.docbook:219
+msgid "Description"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr "El SQL se ejecuta directamente en tu base de datos, de modo que eres libre de usar cualquier dialecto que quieras. Esto reducirá, por supuesto, la portabilidad de tu mapeo si usas SQL específico de la base de datos."
+
+#: index.docbook:223
+msgid "Example"
+msgstr "Los procedimientos almacenados son soportados si está establecido el atributo <literal>callable</literal>:"
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr "El orden de los parámetros posicionales son actualmente vitales, ya que deben estar en la misma secuencia en que las espera Hibernate."
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr "Puedes ver el orden esperado habilitando el registro de depuración para el nivel <literal>org.hibernate.persister.entity</literal>. Con este nivel habilitado, Hibernate imprimirá el SQL estático que se usa para crear, actualizar, borrar, etc. las entidades. (Para ver la secuencia esperada, recuerda no incluir tu SQL personalizado en los ficheros de mapeo ya que sobrescribirán el sql estático generado por Hibernate.)"
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr "Los procedimientos almacenados son, en la mayoría de los casos (léase, mejor hacerlo que no hacerlo), obligados a devolver el número de filas insertadas/actualizadas/borradas, ya que Hibernate tiene algunas comprobaciones en tiempo de ejecución del éxito de la sentencia. Hibernate siempre registra el primer parámetro de la sentencia como un parámetro de salida numérico para las operaciones CUD:"
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr "SQL personalizado para carga"
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr "Puedes también declarar tu propias consultas SQL (o HQL) para cargar entidades:"
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id} \n"
+ " FROM PERSON \n"
+ " WHERE ID=? \n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr "Esto es sólo una declaración de consulta con nombrem como se ha discutido anteriormente. Puedes hacer referencia a esta consulta con nombre en un mapeo de clase:"
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr "Esto incluso funciona con procedimientos almacenados."
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr "Puedes incluso definit una consulta para la carga de colecciones:"
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr "Podrías incluso definir un cargador de entidades que cargue una colección por recuperación por unión (join fetching):"
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/> \n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp \n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr ""
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr ""
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr ""
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr ""
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr ""
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr ""
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr ""
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr ""
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr ""
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr ""
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr ""
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr ""
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr ""
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr ""
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr ""
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr ""
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr ""
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr ""
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr ""
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr ""
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr ""
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr ""
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr ""
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr ""
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr ""
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr ""
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr ""
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr ""
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr ""
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr ""
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr ""
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr ""
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr ""
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr ""
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr ""
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr ""
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr ""
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr ""
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr ""
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr ""
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr ""
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr ""
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr ""
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr ""
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr ""
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr ""
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr ""
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr ""
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr ""
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr ""
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr ""
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr ""
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr ""
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr ""
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr ""
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr ""
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr ""
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr ""
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr ""
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,474 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "appended paragraph 1"
+msgstr "Comienzo rápido con Tomcat"
+
+#: index.docbook:8
+msgid "appended paragraph 2"
+msgstr "Empezando con Hibernate"
+
+#: index.docbook:10
+msgid "appended paragraph 3"
+msgstr "Este tutorial explica una instalación de Hibernate con el contenedor de servlets Apache Tomcat (hemos usado la versión 4.1, las diferencias con la 5.0 deben ser mínimas) para una aplicación basada en web. Hibernate trabaja bien en un entorno manejado con todos los servidores de aplicaciones J2EE importantes, o incluso en aplicaciones Java independientes. El sistema de base de datos es sólo una cuestión de cambiar la configuración del dialecto SQL de Hibernate y las propiedades de conexión."
+
+#: index.docbook:21
+msgid "appended paragraph 4"
+msgstr "Primero, tenemos que copiar todas las bibliotecas requeridas a la instalación de Tomcat. Usamos un contexto web separado (<literal>webapps/quickstart</literal>) para este tutorial, de modo que tenemos que considerar tanto la ruta de búsqueda de bibliotecas global (<literal>TOMCAT/common/lib</literal>) como también el cargador de clases a nivel de contexto en <literal>webapps/quickstart/WEB-INF/lib</literal> (para ficheros JAR) y <literal>webapps/quickstart/WEB-INF/classes</literal>. Nos referiremos a ambos niveles de cargador de clases como el classpath global y el classpath de contexto, respectivamente."
+
+#: index.docbook:32
+msgid "appended paragraph 5"
+msgstr "Ahora, copia las bibliotecas a los dos classpaths:"
+
+#: index.docbook:38
+msgid "appended paragraph 6"
+msgstr "Copia el driver JDBC para la base de datos al classpath global. Esto se requiere para el software de pool de conexiones DBCP que se distribuye con Tomcat. Hibernate usa conexiones JDBC para ejecutar SQL sobre la base de datos, de modo que, o bien tienes que proveer conexiones JDBC en pool, o bien configurar Hibernate para que use uno de los pools soportados directamente (C3P0, Proxool). Para este tutorial, copia la biblioteca <literal>pg74jdbc3.jar</literal> (para PostgreSQL 7.4 y JDK 1.4) al classpath del cargador global. Si quisieras usar una base de datos diferente, simplemente copia su apropiado driver JDBC."
+
+#: index.docbook:51
+msgid "appended paragraph 7"
+msgstr "Nunca copies nada más dentro de la ruta del cargador de clases global en Tomcat, o tendrás problemas con varias herramientas, incluyendo Log4J, commons-logging y otras. Siempre usa el classpath de contexto para cada aplicación web, esto es, copia las bibliotecas a <literal>WEB-INF/lib</literal> y tus propias clases y ficheros de configuración/propiedades a <literal>WEB-INF/classes</literal>. Ambos directorios están a nivel del classpath de contexto por defecto."
+
+#: index.docbook:62
+msgid "appended paragraph 8"
+msgstr "Hibernate está empaquetado como una biblioteca JAR. El fichero <literal>hibernate3.jar</literal> debe ser copiado en el classpath de contexto junto a las otras clases de la aplicación. Hibernate requiere algunas bibliotecas de terceros en tiempo de ejecución; éstas vienen incluídas con la distribución de Hibernate en el directorio <literal>lib/</literal>. Ver <xref linkend=\"3rdpartylibs\"/>. Copia las bibliotecas de terceros requeridas al classpath de contexto."
+
+#: index.docbook:75
+msgid "appended paragraph 9"
+msgstr "Bibliotecas de terceros de Hibernate"
+
+#: index.docbook:83
+msgid "appended paragraph 10"
+msgstr "Biblioteca"
+
+#: index.docbook:86
+msgid "appended paragraph 11"
+msgstr "Descripción"
+
+#: index.docbook:93
+msgid "appended paragraph 12"
+msgstr "antlr (requerida)"
+
+#: index.docbook:96
+msgid "appended paragraph 13"
+msgstr "Hibernate usa ANTLR para producir analizadores de consultas, esta biblioteca también se necesita en tiempo de ejecución."
+
+#: index.docbook:102
+msgid "appended paragraph 14"
+msgstr "dom4j (requerida)"
+
+#: index.docbook:105
+msgid "appended paragraph 15"
+msgstr "Hibernate usa dom4j para analizar ficheros de configuración XML y ficheros de metadatos de mapeo XML."
+
+#: index.docbook:111
+msgid "appended paragraph 16"
+msgstr "CGLIB, asm (requerida)"
+
+#: index.docbook:114
+msgid "appended paragraph 17"
+msgstr "Hibernate usa la biblioteca de generación de código para aumentar las clases en tiempo de ejecución (en combinación con reflección Java)."
+
+#: index.docbook:121
+msgid "appended paragraph 18"
+msgstr "Commons Collections, Commons Logging (requeridas)"
+
+#: index.docbook:124
+msgid "appended paragraph 19"
+msgstr "Hibernate usa varias bibliotecas de utilidad del proyecto Jakarta Commons de Apache."
+
+#: index.docbook:130
+msgid "appended paragraph 20"
+msgstr "EHCache (requerida)"
+
+#: index.docbook:133
+msgid "appended paragraph 21"
+msgstr "Hibernate puede usar varios provedores de caché para el caché de segundo nivel. EHCache es el provedor de caché por defecto si no se cambia en la configuración."
+
+#: index.docbook:140
+msgid "appended paragraph 22"
+msgstr "Log4j (opcional)"
+
+#: index.docbook:143
+msgid "appended paragraph 23"
+msgstr "Hibernate usa la API de Commons Logging, que a su vez puede usar Log4J como el mecanismo de logging subyacente. Si la biblioteca Log4J está disponible en el directorio de bibliotecas del contexto, Commons Logging usará Log4J y la configuración <literal>log4j.properties</literal> en el classpath de contexto. Un fichero de propiedades de ejemplo para Log4J se incluye con la distribución de Hibernate. Así que copia log4j.jar y el fichero de configuración (de <literal>src/</literal>) a tu classpath de contexto si quieres ver que ocurre tras escénas."
+
+#: index.docbook:157
+msgid "appended paragraph 24"
+msgstr "¿Requerida o no?"
+
+#: index.docbook:160
+msgid "appended paragraph 25"
+msgstr "Echa una mirada al fichero <literal>lib/README.txt</literal> en la distribución de Hibernate. Esta es una lista actualizada de bibliotecas de terceros distribuídas con Hibernate. Encontrarás listadas ahí todas las bibliotecas requeridas y opcionales (Observa que \"buildtame required\" significa aquí para la construcción de Hibernate, no de tu aplicación)."
+
+#: index.docbook:174
+msgid "appended paragraph 26"
+msgstr "Ahora instalamos el pooling y modo compartido de conexiones de base de datos tanto en Tomcat como Hibernate. Esto significa que Tomcat proveerá conexiones JDBC en pool (usando su funcionalidad prefabricada de pooling DBCP). Hibernate pide esas conexiones a través de JNDI. Alternativamente, puedes dejar que Hibernate maneje el pool de conexiones. Tomcat liga su pool de conexiones a JNDI; agregamos una declaración de recurso al fichero de configuración principal de Tomcat, <literal>TOMCAT/conf/server.xml</literal>:"
+
+#: index.docbook:184
+msgid "appended paragraph 27"
+msgstr ""
+ "<![CDATA[<Context path=\"/quickstart\" docBase=\"quickstart\">\n"
+ " <Resource name=\"jdbc/quickstart\" scope=\"Shareable\" type=\"javax.sql.DataSource\"/>\n"
+ " <ResourceParams name=\"jdbc/quickstart\">\n"
+ " <parameter>\n"
+ " <name>factory</name>\n"
+ " <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>\n"
+ " </parameter>\n"
+ "\n"
+ " <!-- DBCP database connection settings -->\n"
+ " <parameter>\n"
+ " <name>url</name>\n"
+ " <value>jdbc:postgresql://localhost/quickstart</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>driverClassName</name><value>org.postgresql.Driver</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>username</name>\n"
+ " <value>quickstart</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>password</name>\n"
+ " <value>secret</value>\n"
+ " </parameter>\n"
+ "\n"
+ " <!-- DBCP connection pooling options -->\n"
+ " <parameter>\n"
+ " <name>maxWait</name>\n"
+ " <value>3000</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>maxIdle</name>\n"
+ " <value>100</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>maxActive</name>\n"
+ " <value>10</value>\n"
+ " </parameter>\n"
+ " </ResourceParams>\n"
+ "</Context>]]>"
+
+#: index.docbook:186
+msgid "appended paragraph 28"
+msgstr "El contexto que configuramos en este ejemplo se llama <literal>quickstart</literal>, su base es el directorio <literal>TOMCAT/webapp/quickstart</literal>. Para acceder a cualquier servlet, llama a la ruta <literal>http://localhost:8080/quickstart</literal> en tu navegador (por supuesto, agregando el nombre del servlet como se mapee en tu <literal>web.xml</literal>). Puedes también ir más allá y crear ahora un servlet simple que tenga un método <literal>process()</literal> vacío."
+
+#: index.docbook:196
+msgid "appended paragraph 29"
+msgstr "Tomcat provee ahora conexiones a través de JNDI en <literal>java:comp/env/jdbc/quickstart</literal>. Si tienes problemas obteniendo el pool de conexiones en ejecución, refiérete a la documentación de Tomcat. Si obtienes mensajes de excepción del driver JDBC, intenta instalar primero el pool de conexiones JDBC sin Hibernate. Hay disponibles en la Web tutoriales de Tomcat y JDBC."
+
+#: index.docbook:205
+msgid "appended paragraph 30"
+msgstr "Tu próximo paso es configurar Hibernate. Hibernate tiene que saber cómo debe obtener conexiones JDBC. Usamos la configuración de Hibernate basada en XML. El otro enfoque, usando un ficheros de propiedad, es casi equivalente pero pierde unas pocas funcionalidades que sí permite la sintaxis XML. El fichero de configuración XML se ubica en el classpath de contexto (<literal>WEB-INF/classes</literal>), como <literal>hibernate.cfg.xml</literal>:"
+
+#: index.docbook:214
+msgid "appended paragraph 31"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <property name=\"connection.datasource\">java:comp/env/jdbc/quickstart</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.PostgreSQLDialect</property>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <mapping resource=\"Cat.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:216
+msgid "appended paragraph 32"
+msgstr "Desactivamos el registro (logging) de comandos SQL y decimos a Hibernate qué dialecto SQL de base de datos se usa y dónde obtener conexiones JDBC (declarando la dirección JNDI del pool ligado a Tomcat). El dialecto es una configuración requerida, las bases de datos difieren en su interpretación del \"estándar\" de SQL. Hibernate cuidará de las diferencias y viene con dialectos incluídos para todas las principales bases de datos comerciales y de código abierto."
+
+#: index.docbook:227
+msgid "appended paragraph 33"
+msgstr "Una <literal>SessionFactory</literal> es el concepto de Hibernate de un almacén de datos solo. Pueden usarse múltiples bases de datos creando múltiples ficheros de configuración XML y creando múltiples objetos <literal>Configuration</literal> y <literal>SessionFactory</literal> en tu aplicación."
+
+#: index.docbook:235
+msgid "appended paragraph 34"
+msgstr "El último elemento del <literal>hibernate.cfg.xml</literal> declara <literal>Cat.hbm.xml</literal> como el nombre de un fichero de mapeo XML para la clase persistente <literal>Cat</literal>. Este fichero contiene los metadatos para el mapeo de la clase POJO <literal>Cat</literal> a una tabla (o tablas) de base de datos. Volveremos a este fichero pronto. Escribamos primero la clase POJO y luego declaremos los metadatos de mapeo para ella."
+
+#: index.docbook:248
+msgid "appended paragraph 35"
+msgstr "Primera clase persistente"
+
+#: index.docbook:250
+msgid "appended paragraph 36"
+msgstr "Hibernate trabaja mejor con el modelo de programación de los Viejos Objetos Planos de Java (POJOs, a veces llamados Ordinarios Objetos Planos de Java) para clases persistentes. Un POJO es como un JavaBean, con las propiedades de la clase accesible vía métodos getter y setter, encapsulando la representación interna de la interfaz publicamente visible (Hibernate puede también acceder a los campos directamente, si se necesita):"
+
+#: index.docbook:260
+msgid "appended paragraph 37"
+msgstr ""
+ "<![CDATA[package org.hibernate.examples.quickstart;\n"
+ "\n"
+ "public class Cat {\n"
+ "\n"
+ " private String id;\n"
+ " private String name;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " public Cat() {\n"
+ " }\n"
+ "\n"
+ " public String getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(String id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ "\n"
+ " public void setName(String name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ "\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " public void setSex(char sex) {\n"
+ " this.sex = sex;\n"
+ " }\n"
+ "\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:262
+msgid "appended paragraph 38"
+msgstr "Hibernate no está restringido en su uso de tipos de propiedad, todos los tipos y tipos primitivos del JDK de Java (como <literal>String</literal>, <literal>char</literal> y <literal>Date</literal>) pueden ser mapeados, incluyendo clases del framework de colecciones de Java. Puedes mapearlos como valores, colecciones de valores, o asociaciones a otras entidades. El <literal>id</literal> es una propiedad especial que representa el identificador de base de datos (clave primaria) de la clase. Es altamente recomendado para entidades como un <literal>Cat</literal>. Hibernate puede usar identificadores sólo internamente, pero perderíamos algo de la flexibilidad en nuestra arquitectura de aplicación."
+
+#: index.docbook:275
+msgid "appended paragraph 39"
+msgstr "No tiene que implementarse ninguna interface especial para las clases persistentes ni tienes que subclasear de una clase persistente raíz en especial. Hibernate tampoco requiere ningún procesamiento en tiempo de construcción, como manipulación del byte-code. Se basa solamente en reflección de Java y aumentación de clases en tiempo de ejecución (a través de CGLIB). De modo que, sin ninguna dependencia de la clase POJO en Hibernate, podemos mapearla a una tabla de base de datos."
+
+#: index.docbook:288
+msgid "appended paragraph 40"
+msgstr "Mapeando el gato"
+
+#: index.docbook:290
+msgid "appended paragraph 41"
+msgstr "El fichero de mapeo <literal>Cat.hbm.xml</literal> contiene los metadatos requeridos para el mapeo objeto/relacional. Los metadatos incluyen la declaración de clases persistentes y el mapeo de propiedades (a columnas y relaciones de claves foráneas a otras entidades) a tablas de base de datos."
+
+#: index.docbook:298
+msgid "appended paragraph 42"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"org.hibernate.examples.quickstart.Cat\" table=\"CAT\">\n"
+ "\n"
+ " <!-- A 32 hex character is our surrogate key. It's automatically\n"
+ " generated by Hibernate with the UUID pattern. -->\n"
+ " <id name=\"id\" type=\"string\" unsaved-value=\"null\" >\n"
+ " <column name=\"CAT_ID\" sql-type=\"char(32)\" not-null=\"true\"/>\n"
+ " <generator class=\"uuid.hex\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- A cat has to have a name, but it shouldn' be too long. -->\n"
+ " <property name=\"name\">\n"
+ " <column name=\"NAME\" length=\"16\" not-null=\"true\"/>\n"
+ " </property>\n"
+ "\n"
+ " <property name=\"sex\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:300
+msgid "appended paragraph 43"
+msgstr "Cada clase persistente debe tener un atributo identificador (realmente, sólo las clases que representen entidades, no las clases dependientes de tipo-valor, que son mapeadas como componentes de una entidad). Esta propiedad es usada para distinguir los objetos persistentes: Dos gatos son iguales si <literal>catA.getId().equals(catB.getId())</literal> es verdadero. Este concepto se llama <emphasis>identidad de base de datos (database identity)</emphasis>. Hibernate viene empaquetado con varios generadores de identificador para diferentes escenarios (incluyendo generadores nativos para secuencias de base de datos, tablas de identificadores alto/bajo, e identificadores asignados por aplicación). Usamos el generador UUID (recomendado sólo para pruebas, pues deben preferirse las claves enteras delegadas generadas por la base de datos) y también especificamos la columna <literal>CAT_ID</literal> de la tabla <literal>CAT</literal> para el valor i!
dentificador generado por Hibernate (como una clave primaria de la tabla)."
+
+#: index.docbook:317
+msgid "appended paragraph 44"
+msgstr "Todas las demás propiedades de <literal>Cat</literal> son mapeadas a la misma tabla. En el caso de la propiedad <literal>name</literal>, la hemos mapeado con una declaración explícita de columna de base de datos. Esto es especialmente útil cuando el esquema de base de datos es generado automáticamente (como sentencias DDL de SQL) desde la declaración de mapeo con la herramienta <emphasis>SchemaExport</emphasis> de Hibernate. Todas las demás propiedades son mapeadas usando la configuración por defecto de Hibernate, que es lo que necesitas la mayoría del tiempo. La tabla <literal>CAT</literal> en la base de datos se ve así como:"
+
+#: index.docbook:329
+msgid "appended paragraph 45"
+msgstr ""
+ "<![CDATA[ Columna | Tipo | Modificadores\n"
+ "--------+-----------------------+-----------\n"
+ " cat_id | character(32) | not null\n"
+ " name | character varying(16) | not null\n"
+ " sex | character(1) |\n"
+ " weight | real |\n"
+ "Indexes: cat_pkey primary key btree (cat_id)]]>"
+
+#: index.docbook:331
+msgid "appended paragraph 46"
+msgstr "Ahora debes crear esta tabla manualmente en tu base de datos, y luego leer el <xref linkend=\"toolsetguide\"/> si quieres automatizar este paso con la herramienta <literal>hbm2ddl</literal>. Esta herramienta puede crear un DDL SQL completo, incluyendo definición de tablas, restricciones personalizadas de tipo de columnas, restricciones de unicidad e índices."
+
+#: index.docbook:342
+msgid "appended paragraph 47"
+msgstr "Jugando con gatos"
+
+#: index.docbook:344
+msgid "appended paragraph 48"
+msgstr "Ahora estamos listos para comenzar la <literal>Session</literal> de Hibernate. Es el <emphasis>manejador de persistencia</emphasis> que usamos para almacenar y traer <literal>Cat</literal>s hacia y desde la base de datos. Pero primero, tenemos que obtener una <literal>Session</literal> (unidad de trabajo de Hibernate) de la <literal>SessionFactory</literal>:"
+
+#: index.docbook:352
+msgid "appended paragraph 49"
+msgstr ""
+ "<![CDATA[SessionFactory sessionFactory =\n"
+ " new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:354
+msgid "appended paragraph 50"
+msgstr "La llamada a <literal>configure()</literal> carga el fichero de configuración <literal>hibernate.cfg.xml</literal> e inicializa la instancia de <literal>Configuration</literal>. Puedes establecer otras propiedades (e incluso cambiar los metadatos de mapeo) accediendo a la <literal>Configuration</literal> <emphasis>antes</emphasis> que construyas la <literal>SessionFactory</literal> (que es inmutable). ¿Dónde creamos la <literal>SessionFactory</literal> y cómo accedemos a ella en nuestra aplicación?"
+
+#: index.docbook:365
+msgid "appended paragraph 51"
+msgstr "Una <literal>SessionFactory</literal> usualmente se construye una vez, por ejemplo, al arrancar con un servlet <emphasis>load-on-startup</emphasis>. Esto significa también que no debes mantenerla en una variable de instancia en tus servlets, sino en alguna otro sitio. Además, necesitamos algún tipo de <emphasis>Singleton</emphasis>, de modo que podamos acceder a la <literal>SessionFactory</literal> fácilmente en el código de aplicación. El siguiente enfoque mostrado resuelve ambos problemas: configuración de arranque y fácil acceso a una <literal>SessionFactory</literal>."
+
+#: index.docbook:377
+msgid "appended paragraph 52"
+msgstr "Implementamos una clase de ayuda <literal>HibernateUtil</literal>:"
+
+#: index.docbook:381
+msgid "appended paragraph 53"
+msgstr ""
+ "<![CDATA[import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static Logger log = LoggerFactory.getLogger(HibernateUtil.class);\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " log.error(\"Initial SessionFactory creation failed.\", ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static final ThreadLocal session = new ThreadLocal();\n"
+ "\n"
+ " public static Session currentSession() {\n"
+ " Session s = (Session) session.get();\n"
+ " // Open a new Session, if this Thread has none yet\n"
+ " if (s == null) {\n"
+ " s = sessionFactory.openSession();\n"
+ " session.set(s);\n"
+ " }\n"
+ " return s;\n"
+ " }\n"
+ "\n"
+ " public static void closeSession() {\n"
+ " Session s = (Session) session.get();\n"
+ " if (s != null)\n"
+ " s.close();\n"
+ " session.set(null);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:383
+msgid "appended paragraph 54"
+msgstr "Esta clase no sólo cuida de la <literal>SessionFactory</literal> con su inicializador static, sino que además tiene una variable <literal>ThreadLocal</literal> que tiene la <literal>Session</literal> para la hebra actual. Asegúrate de entender el concepto Java de una variable local a una hebra antes de intentar usar esta ayuda. Una clase <literal>HibernateUtil</literal> más compleja y potente puede encontrarse en <literal>CaveatEmptor</literal>, http://caveatemptor.hibernate.org/"
+
+#: index.docbook:393
+msgid "appended paragraph 55"
+msgstr "Una <literal>SessionFactory</literal> es segura entre hebras, muchas hebras pueden acceder a ella concurrentemente y pedirle <literal>Session</literal>s. Una <literal>Session</literal> no es un objeto seguro entre hebras que representa una sola unidad-de-trabajo con la base de datos. Las <literal>Session</literal>s se abren desde una <literal>SessionFactory</literal> y son cerradas cuando todo el trabajo está completo. Un ejemplo en el método <literal>process()</literal> de tu servlet podría parecerse a esto (sin manejo de excepciones):"
+
+#: index.docbook:404
+msgid "appended paragraph 56"
+msgstr ""
+ "<![CDATA[Session session = HibernateUtil.currentSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Cat princess = new Cat();\n"
+ "princess.setName(\"Princess\");\n"
+ "princess.setSex('F');\n"
+ "princess.setWeight(7.4f);\n"
+ "\n"
+ "session.save(princess);\n"
+ "\n"
+ "tx.commit();\n"
+ "HibernateUtil.closeSession();]]>"
+
+#: index.docbook:406
+msgid "appended paragraph 57"
+msgstr "En una <literal>Session</literal>, cada operación de base de datos ocurre dentro de una transacción que aísla las operaciones de base de datos (incluso operaciones de sólo lectura). Usamos la API de <literal>Transaction</literal> de Hibernate para abstraer de la estrategia de transacciones subyacente (en nuestro caso, transacciones JDBC). Esto permite que nuestro código sea desplegado con transacciones manejadas por contenedor (usando JTA) sin cambio alguno."
+
+#: index.docbook:416
+msgid "appended paragraph 58"
+msgstr "Observa que puedes llamar <literal>HibernateUtil.currentSession();</literal> tantas veces como quieras, siempre obtendrás la <literal>Session</literal> actual de esta hebra. Tienes que asegurarte que la <literal>Session</literal> sea cerrada después que se complete tu unidad-de-trabajo, ya sea en código de tu servlet o en un filtro de servlet antes que la respuesta HTTP sea enviada. El bonito efecto colateral de la segunda opción es la fácil inicialización perezosa: la <literal>Session</literal> todavía está abierta cuando se dibuja la vista, de modo que Hibernate puede cargar objetos no inicializados mientras navegas tu actual grafo de objetos."
+
+#: index.docbook:428
+msgid "appended paragraph 59"
+msgstr "Hibernate tiene varios métodos que pueden ser usados para traer objetos desde la base de datos. La forma más flexible es usando el Lenguaje de Consulta de Hibernate (Hibernate Query Language o HQL), que es una extensión orientada a objetos de SQL fácil de aprender:"
+
+#: index.docbook:436
+msgid "appended paragraph 60"
+msgstr ""
+ "<![CDATA[Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Query query = session.createQuery(\"select c from Cat as c where c.sex = :sex\");\n"
+ "query.setCharacter(\"sex\", 'F');\n"
+ "for (Iterator it = query.iterate(); it.hasNext();) {\n"
+ " Cat cat = (Cat) it.next();\n"
+ " out.println(\"Female Cat: \" + cat.getName() );\n"
+ "}\n"
+ "\n"
+ "tx.commit();]]>"
+
+#: index.docbook:438
+msgid "appended paragraph 61"
+msgstr "Hibernate también ofrece una API <emphasis>consulta por criterios</emphasis> orientada a objetos que puede ser usada para formular consultas de tipo seguro. Por supuesto, Hibernate usa <literal>PreparedStatement</literal>s y ligado de parámetros para toda la comunicación SQL con la base de datos. También puedes usar la funcionalidad de consulta SQL directa de Hibernate u obtener una conexión plana de JDBC de una <literal>Session</literal> en casos raros."
+
+#: index.docbook:451
+msgid "appended paragraph 62"
+msgstr "Finalmente"
+
+#: index.docbook:453
+msgid "appended paragraph 63"
+msgstr "Rasguñamos solamente la superficie de Hibernate en este pequeño tutorial. Por favor, observa que no incluimos ningún código específico de servlet en nuestros ejemplos. Tienes que crear un servlet por tí mismo e insertar el código de Hibernate como lo veas ubicado."
+
+#: index.docbook:461
+msgid "appended paragraph 64"
+msgstr "Ten en mente que Hibernate, como capa de acceso a datos, está firmemente integrado dentro de tu aplicación. Usualmente, todas las otras capas dependen del mecanismo de persistencia. Asegúrate de entender las implicaciones de este diseño."
+
+#: index.docbook:468
+msgid "appended paragraph 65"
+msgstr "Para un ejemplo de aplicación más compleja, ver http://caveatemptor.hibernate.org/ y echa una mirada a los otros tutoriales con links en http://www.hibernate.org/Documentation"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1220 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr "Trabajando con objetos"
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr "Hibernate es una solución completa de mapeo objeto/relacional que no sólo abstrae al desarrollador de los detalles del sistema de manejo de base datos subyacente, sino que además ofrece <emphasis>manejo de estado</emphasis> de objetos. Esto es, al contrario del manejo de <literal>sentencias</literal> SQL en capas comunes de persistencia JDBC/SQL, una vista de la persistencia en aplicaciones Java muy natural y orientada a objetos."
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr "En otras palabras, los desarroladores de aplicaciones Hibernate deben siempre pensar en el <emphasis>estado</emphasis> de sus objetos, y no necesariamente en la ejecución de sentencias SQL. Esta parte es cuidada por Hibernate y es sólo relevante para el desarrollador de la aplicación al afinar el rendimiento del sistema."
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr "Estados de objeto de Hibernate"
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr "Hibernate define y soporta los siguientes estados de objeto:"
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr "<emphasis>Transitorio</emphasis> - un objeto es transitorio si ha sido recién instanciado usando el operador <literal>new</literal>, y no está asociado a una <literal>Session</literal> de Hibernate. No tiene una representación persistente en la base de datos y no se le ha asignado un valor identificador. Las instancias transitorias serán destruídas por el recolector de basura si la aplicación no mantiene más una referencia. Usa la <literal>Session</literal> de Hibernate para hacer un objeto persistente (y deja que Hibernate cuide de las sentencias SQL que necesitan ejecutarse para esta transición)."
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr "<emphasis>Persistente</emphasis> - una instancia persistente tiene una representación en la base de datos y un valor identificador. Puede haber sido salvado o cargado, sin embargo, está por definición en el ámbito de una <literal>Session</literal>. Hibernate detectará cualquier cambio hecho a un objeto en estado persistentey sincronizará el estado con la base de datos cuando se complete la unidad de trabajo. Los desarrolladores no ejecutan sentencias <literal>UPDATE</literal> manuales, o sentencias <literal>DELETE</literal> cuando un objeto debe ser hecho transitorio."
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr "<emphasis>Separado (detached)</emphasis> - una instancia separada es un objeto que ha sido hecho persistente, pero su <literal>Session</literal> ha sido cerrada. La referencia al objeto todavía es válida, por supuesto, y la instancia separada podría incluso ser modificada en este estado. Una instancia separada puede ser re-unida a una nueva <literal>Session</literal> en un punto posterior en el tiempo, haciéndola persistente de nuevo (con todas las modificaciones). Este aspecto habilita un modelo de programación para unidades de trabajo de ejecución larga que requieren tiempo-para-pensar del usuario. Las llamamos <emphasis>transaccciones de aplicación</emphasis>, es decir, una unidad de trabajo desde el punto de vista del usuario."
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr "Discutiremos ahora los estados y transiciones de estados (y los métodos de Hibernate que disparan una transición) en más detalle:"
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr "Haciendo los objetos persistentes"
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr "Las instancias recién instanciadas de una clase persistente son consideradas <emphasis>transitorias</emphasis> por Hibernate. Podemos hacer una instancia transitoria <emphasis>persistente</emphasis> asociándola con una sesión:"
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr "Si <literal>Cat</literal> tiene un identificador generado, el identificador es generado y asignado al <literal>cat</literal> cuando se llama a <literal>save()</literal>. Si <literal>Cat</literal> tiene un identificador <literal>assigned</literal>, o una clave compuesta, el identificador debe ser asignado a la instancia de <literal>cat</literal> antes de llamar a <literal>save()</literal>. Puedes también usar <literal>persist()</literal> en vez de <literal>save()</literal>, con la semántica definida en el temprano borrador de EJB3."
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr "Alternativamente, puedes asignar el identificador usando una versión sobrecargada de <literal>save()</literal>."
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr "Si el objeto que haces persistente tiene objetos asociados (por ejemplo, la colección <literal>kittens</literal> en el ejemplo anterior), estos objetos pueden ser hechos persistentes en cualquier orden que quieras a menos que tengas una restricción <literal>NOT NULL</literal> sobre una columna clave foránea. Nunca hay riesgo de violar restricciones de clave foránea. Sin embargo, podrías violar una restricción <literal>NOT NULL</literal> si llamas a <literal>save()</literal> sobre objetos en orden erróneo."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr "Usualmente no te preocupas con este detalle, pues muy probablemente usarás la funcionalidad de <emphasis>persistencia transitiva</emphasis> de Hibernate para salvar los objetos asociados automáticamente. Entonces, ni siquiera ocurren violaciones de restricciones <literal>NOT NULL</literal> - Hibernate cuidará de todo. La persistencia transitiva se discute más adelante en este capítulo."
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr "Cargando un objeto"
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr "Los métodos <literal>load()</literal> de <literal>Session</literal> te brindan una forma de traer una instancia persistente si ya saves su identificador. <literal>load()</literal> toma un objeto clase y cargará el estado dentro de una instancia recién instanciada de esta clase, en estado persistente."
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr "Alternativamente, puedes cargar estado dentro de una instancia dada:"
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr "Nota que <literal>load()</literal> lanzará una excepción irrecuperable si no hay una fila correspondiente en base de datos. Si la clase es mapeada con un proxy, <literal>load()</literal> sólo devuelve un proxy no inicializado y no llamará realmente a la base de datos hasta que invoques un método del proxy. Este comportamiento es muy útil si deseas crear una asociación a un objeto sin cargarlo realmente de la base de datos. Permite además que múltiples instancias sean cargadas como un lote si se define <literal>batch-size</literal> para el mapeo de la clase."
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr "Si no tienes certeza que exista una fila correspondiente, debes usar el método <literal>get()</literal>, que llama a la base de datos inmediatamente y devuelve nulo si no existe una fila correspondiente."
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr "Puedes incluso cargar un objeto usando un <literal>SELECT ... FOR UPDATE</literal> de SQL, usando un <literal>LockMode</literal>. Ver la documentación de la API para más información."
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr "Ten en cuenta que <emphasis>ninguna</emphasis> instancia asociada o colección contenida es selecciona <literal>FOR UPDATE</literal>, a menos que decidas especificar <literal>lock</literal> o <literal>all</literal> como un estilo de cascada para la asociación."
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr "Es posible volver a cargar un objeto y todas sus colecciones en cualquier momento, usando el método <literal>refresh()</literal>. Esto es útil cuando se usan disparadores de base de datos para inicializar algunas de las propiedades del objeto."
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr "Una cuestión importante aparece usualmente en este punto: ¿Cuánto carga Hibernate de la base de datos y cuántos <literal>SELECT</literal>s de SQL usará? Esto depende de la <emphasis>estrategia de recuperación</emphasis> y se explica en <xref linkend=\"performance-fetching\"/>."
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr "Consultando"
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr "Si no sabes los identificadores de los objetos que estás buscando, necesitas una consulta. Hibernate soporta un lenguaje de consulta orientado a objetos (HQL) fácil de usar pero potente. Para la creación de consultas programáticas, Hibernate soporta una funcionalidad sofisticada de consulta de Criteria y Example (QBC and QBE). También puedes expresar tu consulta en el SQL nativo de tu base de datos, con soporte opcional de Hibernate para la conversión del conjunto resultado en objetos."
+
+#: index.docbook:219
+msgid "Querying"
+msgstr "Ejecutando consultas"
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr "Las consultas HQL y SQL nativas son representadas con una instancia de <literal>org.hibernate.Query</literal>. Esta interface ofrece métodos para la ligación de parámetros, manejo del conjunto resultado, y para la ejecución de la consulta real. Siempre obtienes una <literal>Query</literal> usando la <literal>Session</literal> actual:"
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr "Una consulta se ejecuta usualmente invocando a <literal>list()</literal>, el resultado de la consulta será cargado completamente dentro de una colección en memoria. Las instancias de entidad traídas por una consulta están en estado persistente. El método <literal>uniqueResult()</literal> ofrece un atajo si sabes que tu consulta devolverá sólo un objeto."
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr "Iterando los resultados"
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr "Ocasionalmente, podrías ser capaz de lograr mejor rendimiento al ejecutar la consulta usando el método <literal>iterate()</literal>. Esto sólo será en el caso que esperes que las instancias reales de entidad devueltas por la consulta estén ya en la sesión o caché de segundo nivel. Si todavía no están en caché, <literal>iterate()</literal> será más lento que <literal>list()</literal> y podría requerir muchas llamadas a la base de datos para una consulta simple, usualmente <emphasis>1</emphasis> para la selección inicial que solamente devuelve identificadores, y <emphasis>n</emphasis> selecciones adicionales para inicializar las instancias reales."
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr "Consultas que devuelven tuplas"
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr "Las consultas de Hibernate a veces devuelven tuplas de objetos, en cuyo caso cada tupla se devuelve como un array:"
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];
+\n"
+ " Cat mother = (Cat) tuple[1];
+\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr "Resultados escalares"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr "Las consultas pueden especificar una propiedad de una clase en la cláusula <literal>select</literal>. Pueden incluso llamar a funciones de agregación SQL. Las propiedades o agregaciones son considerados resultados \"escalares\" (y no entidades en estado persistente)."
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr "Ligación de parámetros"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr "Se proveen métodos en <literal>Query</literal> para ligar valores a parámetros con nombre o parámetros <literal>?</literal> de estilo JDBC. <emphasis>Al contrario de JDBC, Hibernate numera los parámetros desde cero.</emphasis> Los parámetros con nombre son identificadores de la forma <literal>:name</literal> en la cadena de la consulta. Las ventajas de los parámetros con nombre son:"
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr "los parámetros con nombre son insensibles al orden en que aparecen en la cadena de consulta"
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr "pueden aparecer múltiples veces en la misma consulta"
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr "son auto-documentados"
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr "Paginación"
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr "Si necesitas especificar límites sobre tu conjunto resultado (el número máximo de filas que quieras traer y/o la primera fila que quieras traer) debes usar los métodos de la interface <literal>Query</literal>:"
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr "Hibernate sabe cómo traducir este límite de consulta al SQL nativo de tu DBMS."
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr "Iteración scrollable"
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr "Si tu driver JDBC soporta <literal>ResultSet</literal>s scrollables, la interface <literal>Query</literal> puede ser usada para obtener un objeto <literal>ScrollableResults</literal>, que permite una navegación flexible de los resultados de consulta."
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr "Nota que se requiere una conexión de base de datos abierta (y cursor) para esta funcionalidad, usa <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> si necesitas la funcionalidad de paginación fuera de línea."
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr "Externalizando consultas con nombre"
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr "Puedes además definir consultas con nombre en el documento de mapeo. (Recuerda usar una sección <literal>CDATA</literal> si tu consulta contiene caracteres que puedan ser interpretados como etiquetado.)"
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+ "<![CDATA[<query name=\"eg.DomesticCat.by.name.and.minimum.weight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr "La ligación de parámetros y ejecución se hace programáticamente:"
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"eg.DomesticCat.by.name.and.minimum.weight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr "Nota que el código real del programa es independiente del lenguaje de consulta usado; puedes además definir consultas SQL nativas en metadatos, o migrar consultas existentes a Hibernate colocándolas en ficheros de mapeo."
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr "Filtrando colecciones"
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr "Un <emphasis>filtro</emphasis> de colección es un tipo especial de consulta que puede ser aplicado a una colección persistente o array. La cadena de consulta puede referirse a <literal>this</literal>, significando el elemento de colección actual."
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr "La colección devuelta es considerada un bag, y es una copia de la colección dada. La colección original no es modificada (esto es contrario a la implicación del nombre \"filtro\", pero consistente con el comportamiento esperado)."
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr "Observa que los filtros no requieren una cláusula <literal>from</literal> (aunque pueden tener uno si se requiere). Los filtros no están limitados a devolver los elementos de colección por sí mismos."
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr "Incluso una consulta de filtro vacío es útil, por ejemplo, para cargar un subconjunto de elementos en una colección enorme:"
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr "Consultas de criterios"
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr "HQL es extremadamente potente pero algunos desarrolladores prefieren construir consultas dinámicamente usando una API orientada a objetos, en vez construir cadenas de consulta. Hibernate provee una API intuitiva de consulta <literal>Criteria</literal> para estos casos:"
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr "Las APIs de <literal>Criteria</literal> y la asociada <literal>Example</literal> son discutidas en más detalle en <xref linkend=\"querycriteria\"/>."
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr "Consultas en SQL nativo"
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr "Puedes expresar una consulta en SQL, usando <literal>createSQLQuery()</literal> y dejando que Hibernate cuide del mapeo de los conjuntos resultado a objetos. Nota que puedes llamar en cualquier momento a <literal>session.connection()</literal> y usar la <literal>Connection</literal> JDBC directamente. Si eliges usar la API de Hibernate, debes encerrar los alias de SQL entre llaves:"
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list();]]>"
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(
+\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +
+\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +
+\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list()]]>"
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr "Las consultas SQL pueden contener parámetros con nombre y posicionales, al igual que las consultas de Hibernate. Puede encontrarse más información sobre consultas en SQL nativo en <xref linkend=\"querysql\"/>."
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr "Modificando objetos persistentes"
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr "Las <emphasis>instancias persistentes transaccionales</emphasis> (es decir, objetos cargados, creados o consultados por la <literal>Session</literal>) pueden ser manipulados por la aplicación y cualquier cambio al estado persistente será persistido cuando la <literal>Session</literal> sea <emphasis>limpiada (flushed)</emphasis> (discutido más adelante en este capítulo). No hay necesidad de llamar un método en particular (como <literal>update()</literal>, que tiene un propósito diferente) para hacer persistentes tus modificaciones. De modo que la forma más directa de actualizar el estado de un objeto es cargarlo con <literal>load()</literal>, y entonces manipularlo directamente, mientras la <literal>Session</literal> está abierta:"
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr "A veces este modelo de programación es ineficiente pues podría requerir una <literal>SELECT</literal> de SQL (para cargar un objeto) y un <literal>UPDATE</literal> de SQL (para hacer persistentes sus datos actualizados) en la misma sesión. Por lo tanto, Hibernate ofrece un enfoque alternativo, usando instancias separadas (detached)."
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr "Nota que Hibernate no ofreve su propia API para ejecución directa de sentencias <literal>UPDATE</literal> o <literal>DELETE</literal>. Hibernate es un servicio de <emphasis>gestión de estado</emphasis>, no tienes que pensar en <literal>sentencias</literal> para usarlo. JDBC es una API perfecta para ejecutar sentencias SQL; puedes obtener una <literal>Connection</literal> JDBC en cualquier momento llamando a <literal>session.connection()</literal>. Además, la noción de operaciones masivas entra en conflicto con el mapeo objeto/relacional en aplicaciones en línea orientadas al procesamiento de transacciones. Versiones futuras de Hibernate pueden, sin embargo, proveer funciones de operación masiva especiales. Ver <xref linkend=\"batch\"/> por algunos trucos de operación en lote (batch) posibles."
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr "Modificando objetos separados"
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr "Muchas aplicaciones necesitan recuperar un objeto en una transacción, enviarla a la capa de UI para su manipulación, y entonces salvar los cambios en una nueva transacción. Las aplicaciones que usan este tipo de enfoque en un entorno de alta concurrencia usualmente usan datos versionados para asegurar el aislamiento de la unidad de trabajo \"larga\"."
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr "Hibernate soporta este modelo al proveer re-unión de instancias separadas usando los métodos <literal>Session.update()</literal> o <literal>Session.merge()</literal>:"
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr "Si el <literal>Cat</literal> con identificador <literal>catId</literal> ya hubiera sido cargado por <literal>secondSession</literal> cuando la aplicación intentó volver a unirlo, se habría lanzado una excepción."
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr "Usa <literal>update()</literal> si no estás seguro que la sesión tenga una instancia ya persistente con el mismo identificador, y <literal>merge()</literal> si quieres fusionar tus modificaciones en cualquier momento sin consideración del estado de la sesión. En otras palabras, <literal>update()</literal> es usualmente el primer método que llamarías en una sesión fresca, asegurando que la re-unión de tus instancias separadas es la primera operación que se ejecuta."
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr "La aplicación debe actualizar individualmente las instancias separadas alcanzables por la instancia separada dada llamando a <literal>update()</literal>, si y <emphasis>sólo</emphasis> si quiere que sus estados sean también actualizados. Esto puede, por supuesto, ser automatizado usando <emphasis>persistencia transitiva</emphasis>, ver <xref linkend=\"objectstate-transitive\"/>."
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr "El método <literal>lock()</literal> también permite a una aplicación reasociar un objeto con una sesión nueva. Sin embargo, la instancia separada no puede haber sido modificada!"
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr "Nota que <literal>lock()</literal> puede ser usado con varios <literal>LockMode</literal>s, ver la documentación de la API y el capítulo sobre manejo de transacciones para más información. La re-unión no es el único caso de uso para <literal>lock()</literal>."
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr "Se discuten otros modelos para unidades de trabajo largas en <xref linkend=\"transactions-optimistic\"/>."
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr "Detección automática de estado"
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr "Los usuarios de Hibernate han pedido un método de propósito general que bien salve una instancia transitoria generando un identificador nuevo, o bien actualice/reúna las instancias separadas asociadas con su identificador actual. El método <literal>saveOrUpdate()</literal> implementa esta funcionalidad."
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr "El uso y semántica de <literal>saveOrUpdate()</literal> parece ser confuso para usuarios nuevos. Primeramente, en tanto no estés intentando usar instancias de una sesión en otra sesión nueva, no debes necesitar usar <literal>update()</literal>, <literal>saveOrUpdate()</literal>, o <literal>merge()</literal>. Algunas aplicaciones enteras nunca usarán ninguno de estos métodos."
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr "Usualmente <literal>update()</literal> o <literal>saveOrUpdate()</literal> se usan en el siguiente escenario:"
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr "la aplicación carga un objeto en la primera sesión"
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr "el objeto es pasado a la capa de UI"
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr "se hacen algunas modificaciones al objeto"
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr "el objeto se pasa abajo de regreso a la capa de negocio"
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr "la aplicación hace estas modificaciones persistentes llamando a <literal>update()</literal> en una segunda sesión"
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr "<literal>saveOrUpdate()</literal> hace lo siguiente:"
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr "si el objeto ya es persistente en esta sesión, no hace nada"
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr "si otro objeto asociado con la sesión tiene el mismo identificador, lanza una excepción"
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr "si el objeto no tiene ninguna propiedad identificadora, lo salva llamando a <literal>save()</literal>"
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr "si el identificador del objeto tiene el valor asignado a un objeto recién instanciado, lo salva llamando a <literal>save()</literal>"
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr "si el objeto está versionado (por un <literal><version></literal> o <literal><timestamp></literal>), y el valor de la propiedad de versión es el mismo valor asignado a una objeto recién instanciado, lo salva llamando a <literal>save()</literal>"
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr "en cualquier otro caso se actualiza el objeto llamando a <literal>update()</literal>"
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "y <literal>merge()</literal> es muy diferente:"
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "si existe una instancia persistente con el mismo identificador asignado actualmente con la sesión, copia el estado del objeto dado en la instancia persistente"
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr "si no existe ninguna instancia persistente actualmente asociada a la sesión, intente cargarla de la base de datos, o crear una nueva instancia persistente"
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr "la instancia persistente es devuelta"
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr "la instancia dada no resulta ser asociada a la sesión, permanece separada"
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr "Borrando objetos persistentes"
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr "<literal>Session.delete()</literal> quitará el estado de un objeto de la base de datos. Por supuesto, tu aplicación podría tener aún una referencia a un objeto borrado. Lo mejor es pensar en <literal>delete()</literal> como hacer transitoria una instancia persistente."
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr "<![CDATA[sess.delete(cat);]]>"
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr "Puedes borrar los objetos en el orden que gustes, sin riesgo de violaciones de restricción de clave foránea. Aún es posible violar una restricción <literal>NOT NULL</literal> sobre una columna clave foránea borrando objetos en un orden erróneo, por ejemplo, si borras el padre, pero olvidas borrar los hijos."
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr "Replicando objetos entre dos almacénes de datos diferentes"
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr "Es ocasionalmente útil ser capaz de tomar un grafo de instancias persistentes y hacerlas persistentes en un almacén de datos diferente, sin regenerar los valores identificadores."
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr "El <literal>ReplicationMode</literal> determina cómo <literal>replicate()</literal> tratará los conflictos con filas existentes en la base de datos."
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr "<literal>ReplicationMode.IGNORE</literal> - ignora el objeto cuando existe una fila de base de datos con el mismo identificador"
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr "<literal>ReplicationMode.OVERWRITE</literal> - sobrescribe cualquier fila de base de datos existente con el mismo identificador"
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr "<literal>ReplicationMode.EXCEPTION</literal> - lanza una excepción si existe una fila de base de datos con el mismo identificador"
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.LATEST_VERSION</literal> - sobrescribe la fila si su número de versión es anterior al número de versión del objeto, o en caso contrario ignora el objeto"
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr "Los casos de uso para esta funcionalidad incluyen reconciliar datos ingresados en instancias diferentes de bases de datos, actualizar información de configuración de sistema durante actualizaciones de producto, deshacer cambios producidos durante transacciones no-ACID y más."
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr "Limpiando (flushing) la sesión"
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr "Cada tanto, la <literal>Session</literal> ejecutará las sentencias SQL necesarias para sincronizar el estado de la conexión JDBC con el estado de los objetos mantenidos en menoria. Este proceso, <emphasis>limpieza (flush)</emphasis>, ocurre por defecto en los siguientes puntos"
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr "antes de algunas ejecuciones de consulta"
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr "desde <literal>org.hibernate.Transaction.commit()</literal>"
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr "desde <literal>Session.flush()</literal>"
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr "Las sentencias SQL son liberadas en el siguiente orden"
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr "todas las inserciones de entidades, en el mismo orden que los objetos correspondientes fueron salvados usando <literal>Session.save()</literal>"
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr "todas las actualizaciones de entidades"
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr "todas los borrados de colecciones"
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr "todos los borrados, actualizaciones e inserciones de elementos de colección"
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr "todas las inserciones de colecciones"
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr "todos los borrados de entidades, en el mismo orden que los objetos correspondientes fueron borrados usando <literal>Session.delete()</literal>"
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr "(Una excepción es que los objetos que usan generación de ID <literal>native</literal> se insertan cuando son salvados.)"
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr "Excepto cuando llamas explícitamente a <literal>flush()</literal>, no hay en absoluto garantías sobre <emphasis>cuándo</emphasis> la <literal>Session</literal> ejecuta las llamadas JDBC. sólo sobre el <emphasis>orden</emphasis> en que son ejecutadas. Sin embargo, Hibernate garantiza que los métodos <literal>Query.list(..)</literal> nunca devolverán datos añejos o erróneos."
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr "Es posible cambiar el comportamiento por defecto de modo que la limpieza (flush) ocurra menos frecuentemente. La clase <literal>FlushMode</literal> tres modos diferentes: sólo en tiempo de compromiso (y sólo cuando se use la API de <literal>Transaction</literal> de Hibernate), limpieza automática usando la rutina explicada, o nunca limpiar a menos que se llame a <literal>flush()</literal> explícitamente. El último modo es útil para unidades de trabajo largas, donde una <literal>Session</literal> se mantiene abierta y desconectada por largo tiempo (ver <xref linkend=\"transactions-optimistic-longsession\"/>)."
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs]]>"
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr "Durante la limpieza, puede ocurrir una excepción (por ejemplo, si una operación DML violase una restricción). Ya que el manejo de excepciones implica alguna comprensión del comportamiento transaccional de Hibernate, lo discutimos en <xref linkend=\"transactions\"/>."
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr "Persistencia transitiva"
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr "Es absolutamente incómodo dalvar, borrar, o reunir objetos individuales, especialmente si tratas con un grafo de objetos asociados. Un caso común es una relación padre/hijo. Considera el siguiente ejemplo:"
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr "Si los hijos en una relación padre/hijo pudieran ser tipificados en valor (por ejemplo, una colección de direcciones o cadenas), sus ciclos de vida dependerían del padre y se requeriría ninguna otra acción para el tratamiento en \"cascada\" de cambios de estado. Cuando el padre es salvado, los objetos hijo tipificados en valor son salvados también, cuando se borra el padre, se borran los hijos, etc. Esto funciona incluso para operaciones como el retiro de un hijo de la colección. Hibernate detectará esto y, ya que los objetos tipificados en valor no pueden tener referencias compartidas, borrará el hijo de la base de datos."
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr "Ahora considera el mismo escenario con los objetos padre e hijos siendo entidades, no tipos de valor (por ejemplo, categorías e ítems, o gatos padre e hijos). Las entidades tienen su propio ciclo de vida, soportan referencias compartidas (de modo que quitar una entidad de una colección no significa que sea borrada), y no hay por defecto ningún tratamiento en \"cascada\" de estado de una entidad a otras entidades asociadas. Hibernate no implementa <emphasis>persistencia por alcance</emphasis>."
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr "Para cada operación básica de la sesión de Hibernate - incluyendo <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - hay un estilo de cascada correspondiente. Respectivamente, los estilos de cascada se llaman <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. Si quieres que una operación sea tratada en cascada a lo largo de una asociación, debes indicar eso en el documento de mapeo. Por ejemplo:"
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr "Los estilos de cascada pueden combinarse:"
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr "Puedes incluso usar <literal>cascade=\"all\"</literal> para especificar que <emphasis>todas</emphasis> las operaciones deben ser tratadas en cascada a lo largo de la asociación. El por defecto <literal>cascade=\"none\"</literal> especifica que ninguna operación será tratada en cascada."
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr "Un estilo de cascada especial, <literal>delete-orphan</literal>, se aplica sólo a asociaciones uno-a-muchos, e indica que la operación <literal>delete()</literal> debe aplicarse a cualquier objeto hijo que sea quitado de la asociación."
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr "Recomendaciones:"
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr "Usualmente no tiene sentido habilitar el tratamiento en cascada a una asociación <literal><many-to-one></literal> o <literal><many-to-many></literal>. El tratamiento en cascada es frecuentemente útil para las asociaciones <literal><one-to-one></literal> y <literal><one-to-many></literal>. associations."
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr "Si la esperanza de vida de los objetos hijos está ligada a la eesperanza de vida del objeto padre, házlo un <emphasis>objeto de ciclo de vida</emphasis> especificando <literal>cascade=\"all,delete-orphan\"</literal>."
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr "En otro caso, puede que no necesites tratamiento en cascada en absoluto. Pero si piensas que estarás trabajando frecuentemente con padre e hijos juntos en la misma transacción, y quieres ahorrarte algo de tipeo, considera usar <literal>cascade=\"persist,merge,save-update\"</literal>."
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr "Mapear una asociación (ya sea una asociación monovaluada, o una colección) con <literal>cascade=\"all\"</literal> marca la asociación como una relación del estilo <emphasis>padre/hijo</emphasis> donde save/update/delete en el padre resulta en save/update/delete del hijo o hijos."
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr "Además, una mera referencia a un hijo desde un padre persistente resultará en un save/update del hijo. Esta metáfora está incompleta, sin embargo. Un hijo que deje de ser referenciado por su padre <emphasis>no</emphasis> es borrado automáticamente, excepto en el caso de una asociación <literal><one-to-many></literal> mapeada con <literal>cascade=\"delete-orphan\"</literal>. La semántica precisa de las operaciones en cascada para una relación padre/hijo es:"
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr "Si un padre le es pasado a <literal>persist()</literal>, todos los hijos le son pasados a <literal>persist()</literal>"
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr "Si un padre le es pasado a <literal>merge()</literal>, todos los hijos le son pasados a <literal>merge()</literal>"
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr "Si un padre le es pasado a <literal>save()</literal>, <literal>update()</literal> o <literal>saveOrUpdate()</literal>, todos los hijos le son pasados a <literal>saveOrUpdate()</literal>"
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr "Si un hijo transitorio o separado se vuelve referenciado por un padre persistente, le es pasado a <literal>saveOrUpdate()</literal>"
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr "Si un padre es borrado, todos los hijos le son pasados a <literal>delete()</literal>"
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr "Si un hijo deja de ser referenciado por un padre persistente, <emphasis>no ocurre nada especial</emphasis> - la aplicación debe borrar explícitamente el hijo de ser necesario - a menos que <literal>cascade=\"delete-orphan\"</literal>, en cuyo caso el hijo \"huérfano\" es borrado."
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr "Usando metadatos"
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr "Hibernate requiere de un modelo de meta-nivel muy rico de todas las entidades y tipos de valor. De vez en cuando, este modelo es muy útil para la aplicación misma. Por ejemplo, la aplicación podría usar los metadatos de Hibernate para implementar un algoritmo \"inteligente\" de copia en profundidad que entienda qué objetos deben ser copiados (por ejemplo, tipo de valor mutables) y cuáles no (por ejemplo, tipos de valor inmutables y, posiblemente, entidades asociadas)."
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr "Hibernate expone los metadatos vía las interfaces <literal>ClassMetadata</literal> y <literal>CollectionMetadata</literal> y la jerarquía <literal>Type</literal>. Las instancias de las interfaces de metadatos pueden obtenerse de <literal>SessionFactory</literal>."
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,725 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr "Guía del Conjunto de Herramientas"
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr "La ingeniería de ida y vuelta con Hibernate es posible usando un conjunto de plugins de Eclipse, herramientas de línea de comandos, así como tareas de Ant."
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "Las <emphasis>Herramientas de Hibernate</emphasis> actualmente incluyen plugins para la IDE de Eclipse así como tareas de Ant para la ingeniería inversa de bases de datos existentes:"
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr "<emphasis>Editor de Mapeo:</emphasis> Un editor de ficheros de mapeo XML, que soporta autocompleción y resaltado de sintáxis. Soporta también autocompleción semántica de nombres de clases y nombres de campos/propiedades, haciéndolo mucho más versátil que un editor de XML normal."
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>Consola:</emphasis> La consola es una nueva vista en Eclipse. Además de la vista de árbol de tus configuraciones de consola, tienes también una vista interactiva de tus clases persistentes y sus relaciones. La console te permite ejecutar consultas HQL contra tu base de datos y navegar el resultado directamente en Eclipse."
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>Asistentes de Desarrollo:</emphasis> Se proveen muchos asistentes con las herramientas de Eclipse. Puedes usar un asistente para generar rápidamente ficheros de configuración de Hibernate (cfg.xml), o incluso puedes haceruna ingeniería inversa completa de un esquema de base de datos existente en ficheros de código de POJO y ficheros de mapeo de Hibernate. El asistente de ingeniería inversa soporta plantillas personalizables."
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr "Tareas de Ant:"
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr "Por favor refiérete al paquete <emphasis>Herramientas de Hibernate</emphasis> y su documentación para más información."
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr "Sin embargo, el paquete principal de Hibernate viene incluyendo una herramienta integrada (puede ser usada incluso \"dentro\" de Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> también conocido como <literal>hbm2ddl</literal>."
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr "Generación automática de esquemas"
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "Una utilidad de Hibernate puede generar DDL desde tus ficheros de mapeo. El esquema generado incluye restricciones de integridad referencial (claves primarias y foráneas) para las tablas de entidades y colecciones. Las tablas y secuencias también son creadas para los generadores de identificadores mapeados."
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr "<emphasis>Debes</emphasis> especificar un <literal>Dialecto</literal> SQL vía la propiedad <literal>hibernate.dialect</literal> al usar esta herramienta, ya que el DDL es altamente específico del vendedor."
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr "First, customize your mapping files to improve the generated schema."
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr "Personalizando el esquema"
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr "Muchos elementos de mapeo de Hibernate definen un atributo opcional llamado <literal>length</literal>. Con este atributo puedes establecer el tamaño de una columna. (O, para tipos de datos numéricos/decimales, la precisión.)"
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr "Algunas etiquetas también aceptan un atributo <literal>not-null</literal> (para generar una restricción <literal>NOT NULL</literal> en columnas de tablas) y y un atributo <literal>unique</literal> (para generar restricciones <literal>UNIQUE</literal> en columnas de tablas)."
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr "Algunas etiquetas aceptan un atributo <literal>index</literal> para especificar el nombre de un índice para esa columna. Se puede usar un atributo <literal>unique-key</literal> para agrupar columnas en una restricción de clave de una sola unidad. Actualmente, el valor especificado del atributo <literal>unique-key</literal> <emphasis>no</emphasis> es usado para nombrar la restricción, sólo para agrupar las columnas en el fichero de mapeo."
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr "Ejemplos:"
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"string\" length=\"64\" not-null=\"true\"/>\n"
+ "\n"
+ "<many-to-one name=\"bar\" foreign-key=\"fk_foo_bar\" not-null=\"true\"/>\n"
+ "\n"
+ "<element column=\"serial_number\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr "Alternativamente, estos elementos aceptan tambíen un elemento hijo <literal><column></literal>. Esto es particularmente útil para tipos multicolumnas:"
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"string\">\n"
+ " <column name=\"foo\" length=\"64\" not-null=\"true\" sql-type=\"text\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"bar\" type=\"my.customtypes.MultiColumnType\"/>\n"
+ " <column name=\"fee\" not-null=\"true\" index=\"bar_idx\"/>\n"
+ " <column name=\"fi\" not-null=\"true\" index=\"bar_idx\"/>\n"
+ " <column name=\"fo\" not-null=\"true\" index=\"bar_idx\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr "El atributo <literal>sql-type</literal> permite al usuario sobrescribir el mapeo por defecto de tipo Hibernate a tipo de datos SQL."
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr "El atributo <literal>check</literal> te permite especificar una comprobación de restricción."
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "Resumen"
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr "Atributo"
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr "Valores"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr "Interpretación"
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr "length"
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "number"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr "largo de columna/precisión decimal"
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr "not-null"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr "true|false"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr "especifica que la columna debe ser no nulable"
+
+#: index.docbook:156
+msgid "Summary"
+msgstr "unique"
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr "true|false"
+
+#: index.docbook:164
+msgid "Values"
+msgstr "especifica que la columna debe tener una restricción de unicidad"
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr "index"
+
+#: index.docbook:170
+msgid "length"
+msgstr "index_name"
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr "especifica el nombre de un índice (multicolumna)"
+
+#: index.docbook:172
+msgid "column length"
+msgstr "unique-key"
+
+#: index.docbook:175
+msgid "precision"
+msgstr "unique_key_name"
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr "foreign-key"
+
+#: index.docbook:180
+msgid "scale"
+msgstr "foreign_key_name"
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr "sql-type"
+
+#: index.docbook:185
+msgid "not-null"
+msgstr "column_type"
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr "sobrescribe el tipo de columna por defecto (sólo atributo del elemento <literal><column></literal>)"
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr "check"
+
+#: index.docbook:190
+msgid "unique"
+msgstr "expresión SQL"
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr "El elemento <literal><comment></literal> te permite especificar un comentario para el esquema generado."
+
+#: index.docbook:195
+msgid "index"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:196
+msgid "index_name"
+msgstr ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr "Esto resulta en una sentencia <literal>comment on table</literal> o <literal>comment on column</literal> en el DDL generado (donde esté soportado)."
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr "Ejecutando la herramienta"
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr "La herramienta <literal>SchemaExport</literal> escribe un guión DDL a la salida estándar y/o ejecuta las sentencias DDL."
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr "<literal>java -cp </literal><emphasis>classpaths_de_hibernate</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>opciones ficheros_de_mapeo</emphasis>"
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr "Opciones de Línea de Comandos de <literal>SchemaExport</literal>"
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr "Opción"
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "Descripción"
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr "--quiet"
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr "no enviar a salida estándar el guión"
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr "--drop"
+
+#: index.docbook:225
+msgid "default"
+msgstr "sólo desechar las tablas"
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr "--text"
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr "no exportar a la base de datos"
+
+#: index.docbook:232
+msgid "check"
+msgstr "--output=my_schema.ddl"
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr "--config=hibernate.cfg.xml"
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr "lee la configuración de Hibernate de un fichero XML"
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr "lee las propiedades de base de datos de un fichero"
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr "--format"
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr "formatea agradablemente el SQL generado en el guión"
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "--delimiter=x"
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "establece un delimitador de fin de línea para el guión"
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr "Puedes incluso encajar <literal>SchemaExport</literal> en tu aplicación:"
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr "Propiedades"
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr "Las propiedades de base de datos pueden especificarse"
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr "como propiedades de sistema con <literal>-D</literal><emphasis><property></emphasis>"
+
+#: index.docbook:289
+msgid "--drop"
+msgstr "en <literal>hibernate.properties</literal>"
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr "en un fichero de propiedades mencionado con <literal>--properties</literal>"
+
+#: index.docbook:293
+msgid "--create"
+msgstr "Las propiedades necesarias son:"
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr "Propiedades de Conexión de SchemaExport"
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr "Nombre de Propiedad"
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr "Descripción"
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr "clase del driver jdbc"
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr "url de jdbc"
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr "usuario de base de datos"
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr "contraseña de usuario"
+
+#: index.docbook:317
+msgid "--format"
+msgstr "hibernate.dialect"
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr "dialecto"
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr "Usando Ant"
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr "Puedes llamar a <literal>SchemaExport</literal> desde tu guión de construcción de Ant:"
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr "Actualizaciones incrementales de esquema"
+
+#: index.docbook:337
+msgid "Properties"
+msgstr "La herramienta <literal>SchemaUpdate</literal> actualizará un esquema existente con cambios \"incrementales\". Nota que <literal>SchemaUpdate</literal> depende fuertemente de la API de metadatos de JDBC, de modo que no funcionará con todos los drivers JDBC."
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr "<literal>java -cp </literal><emphasis>classpaths_de_hibernate</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>opciones ficheros_de_mapeo</emphasis>"
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "Opciones de Línea de Comandos de <literal>SchemaUpdate</literal>"
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr "Opción"
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr "Descripción"
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr "--quiet"
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr "no enviar a salida estándar el guión"
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr "Puedes encajar <literal>SchemaUpdate</literal> en tu aplicación:"
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr "Usando Ant para actualizaciones incrementales de esquema"
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr "Puedes llamar a <literal>SchemaUpdate</literal> desde el guión de Ant:"
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+
+#: index.docbook:381
+msgid "database user"
+msgstr ""
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: index.docbook:385
+msgid "user password"
+msgstr ""
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr ""
+
+#: index.docbook:389
+msgid "dialect"
+msgstr ""
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr ""
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr ""
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr ""
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr ""
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr ""
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr ""
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr ""
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr ""
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr ""
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr ""
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr ""
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr ""
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr ""
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr ""
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr ""
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr ""
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr ""
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr ""
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,738 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr "Transacciones y Concurrencia"
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "El punto más importante sobre Hibernate y el control de concurrencia es que muy fácil de comprender. Hibernate usa directamente conexiones JDBC y recursos JTA sin agregar ningún comportamiento de bloqueo adicional. Recomendamos altamente que gastes algo de tiempo con la especificación de JDBC, ANSI, y el aislamiento de transacciones de tu sistema de gestión de base de datos. Hibernate sólo añade versionado automático pero no bloquea objetos en memoria ni cambia el nivel de aislamiento de tus transacciones de base de datos. Básicamente, usa Hibernate como usarías JDBC directo (o JTA/CMT) con tus recursos de base de datos."
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr "Sin embargo, además del versionado automático, Hibernate ofrece una API (menor) para bloqueo pesimista de filas, usando la sintáxis <literal>SELECT FOR UPDATE</literal>. Esta API se discute más adelante en este capítulo:"
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "Comenzamos la discusión del control de concurrencia en Hibernate con la granularidad de <literal>Configuration</literal>, <literal>SessionFactory</literal>, y <literal>Session</literal>, así como la base de datos y las transacciones de aplicación largas."
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "Ámbitos de sesión y de transacción"
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr "Una <literal>SessionFactory</literal> es un objeto seguro entre hebras caro-de-crear pensado para ser compartido por todas las hebras de la aplicación. Es creado una sola vez, usualmente en el arranque de la aplicación, a partir de una instancia de <literal>Configuration</literal>."
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "Una <literal>Session</literal> es un objeto barato, inseguro entre hebras que debe ser usado una sola vez, para un solo proceso de negocio, una sola unidad de trabajo, y luego descartado. Una <literal>Session</literal> no obtendrá una <literal>Connection</literal> JDBC (o un <literal>Datasource</literal>) a menos que sea necesario, de modo que puedas abrir y cerrar seguramente una <literal>Session</literal> incluso si no estás seguro que se necesitará acceso a los datos para servir una petición en particular. (Esto se vuelve importante en cuanto estés implementando alguno de los siguientes patrones usando intercepción de peticiones)."
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr "Para completar este cuadro tienes que pensar también en las transacciones de base de datos. Una transacción de base de datos tiene que ser tan corta como sea posible, para reducir la contención de bloqueos en la base de datos. Las transacciones largas de base de datos prevendrán a tu aplicación de escalar a una carga altamente concurrente."
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr "¿Qué es el ámbito de una unidad de trabajo? ¿Puede una sola <literal>Session</literal> de Hibernate extenderse a través de varias transacciones de base de datos o es ésta una relación uno-a-uno de ámbitos? ¿Cuándo debes abrir y cerrar una <literal>Session</literal> y cómo demarcas los límites de la transacción de base de datos?"
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr "Unidad de trabajo"
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr "Primero, no uses el antipatrón <emphasis>sesión-por-operación</emphasis>, esto es, ¡no abras y cierres una <literal>Session</literal> para cada simple llamada a la base de datos en una sola hebra! Por supuesto, lo mismo es verdad para transacciones de base de datos. Las llamadas a base de datos en una aplicación se hacen usando una secuencia prevista, que están agrupadas dentro de unidades de trabajo atómicas. (Nota que esto también significa que el auto-commit después de cada una de las sentencias SQL es inútil en una aplicación, este modo está pensado para trabajo ad-hoc de consola SQL. Hibernate deshabilita, o espera que el servidor de aplicaciones lo haga, el modo auto-commit inmediatamente.)"
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr "El patrón más común en una aplicación mutiusuario cliente/servidor es <emphasis>sesión-por-petición</emphasis>. En este modelo, una petición del cliente es enviada al servidor (en donde se ejecuta la capa de persistencia de Hibernate), se abre una nueva <literal>Session</literal> de Hibernate, y todas las operaciones de base de datos se ejecutan en esta unidad de trabajo. Una vez completado el trabajo (y se ha preparado la respuesta para el cliente) la sesión es limpiada y cerrada. Podrías usar una sola transacción de base de datos para servir a petición del cliente, comenzándola y comprometiéndola cuando abres y cierras la <literal>Session</literal>. La relación entre las dos es uno-a-uno y este modelo es a la medida perfecta de muchas aplicaciones."
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "El desafío yace en la implementación: no sólo tienen que comenzarse y terminarse correctamente la <literal>Session</literal> y la transacción, sino que además tienen que estar accesibles para las operaciones de acceso a datos. La demarcación de una unidad de trabajo se implementa idealmente usando un interceptor que se ejecuta cuando una petición llama al servidor y anter que la respuesta sea enviada (es decir, un <literal>ServletFilter</literal>). Recomendamos ligar la <literal>Session</literal> a la hebra que atiende la petición, usando una variable <literal>ThreadLocal</literal>. Esto permite un fácil acceso (como acceder a una variable static) en tódo el código que se ejecuta en esta hebra. Dependiendo del mecanismo de demarcación de transacciones de base de datos que elijas, podrías mantener también el contexto de la transacción en una variable <literal>Thre!
adLocal</literal>. Los patrones de implementación para esto son conocidos como <emphasis>Sesión Local de Hebra (ThreadLocal Session)</emphasis> y <emphasis>Sesión Abierta en Vista (Open Session in View)</emphasis>. Puedes extender fácilmente la clase de ayuda <literal>HibernateUtil</literal> mostrada anteriormente para encontrar una forma de implementar un interceptor e instalarlo en tu entorno. Ver el sitio web de Hibernate para consejos y ejemplos."
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr "Transacciones de aplicación"
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "El patrón sesión-por-petición no es el único concepto útil que puedes usar para diseñar unidades de trabajo. Muchos procesos de negocio requiere una serie completa de interacciones con el usuario intercaladas con accesos a base de datos. En aplicaciones web y de empresa no es aceptable que una transacción de base de datos se extienda a través de la interacción de un usuario. Considera el siguiente ejemplo:"
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "Se abre la primera pantalla de un diálogo, los datos vistos por el usuario han sido cargados en una <literal>Session</literal> y transacción de base de datos particular. El usuario es libre de modificar los objetos."
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr "El usuario hace click en \"Salvar\" después de 5 minutos y espera que sus modificaciones sean hechas persistentes. También espera que él sea la única persona editando esta información y que no puede ocurrir ninguna modificación en conflicto."
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "Llamamos a esto unidad de trabajo, desde el punto de vista del usuario, una larga <emphasis>transacción de aplicación</emphasis> ejecutándose. Hay muchas formas en que puedes implementar esto en tu aplicación."
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "Una primera implementación ingenua podría mantener abierta la <literal>Session</literal> y la transacción de base de datos durante el tiempo de pensar del usuario, con bloqueos tomados en la base de datos para prevenir la modificación concurrente, y para garantizar aislamiento y atomicidad. Esto es, por supuesto, un antipatrón, ya que la contención de bloqueo no permitiría a la aplicación escalar con el número de usuarios concurrentes."
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr "Claramente, tenemos que usar muchas transacciones de base de datos para implementar la transacción de aplicación. En este caso, mantener el aislamiento de los procesos de negocio se vuelve una responsabilidad parcial de la capa de aplicación. Una sola transacción de aplicación usualmente abarca varias transacciones de base de datos. Será atómica si sólo una de estas transacciones de base de datos (la última) almacena los datos actualizados, todas las otras simplemente leen datos (por ejemplo, en un diálogo estilo-asistente abarcando muchos ciclos petición/respuesta). Esto es más fácil de implementar de lo que suena, especialmente si usas las funcionalidades de Hibernate:"
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr "<emphasis>Versionado Automático</emphasis> - Hibernate puede llevar un control automático de concurrencia optimista por ti, puede detectar automáticamente si una modificación concurrente ha ocurrido durante el tiempo de pensar del usuario."
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "<emphasis>Objetos Separados</emphasis> - Si decides usar el ya discutido patrón de <emphasis>sesión-por-petición</emphasis>, todas las instancias cargadas estarán en estado separado durante el tiempo de pensar del usuario. Hibernate te permite volver a unir los objetos y hacer persistentes las modificaciones. El patrón se llama <emphasis>sesión-por-petición-con-objetos-separados</emphasis>. Se usa versionado automático para aislar las modificaciones concurrentes."
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr "<emphasis>Sesión Larga</emphasis> - La <literal>Session</literal> de Hibernate puede ser desconectada de la conexión JDBC subyacente después que se haya sido comprometida la transacción de base de datos, y reconectada cuando ocurra una nueva petición del cliente. Este patrón es conocido como <emphasis>sesión-por-transacción-de-aplicación</emphasis> y hace la re-unión innecesaria. Para aislar las modificaciones concurrentes se usa el versionado automático."
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr "Tanto <emphasis>sesión-por-petición-con-objetos-separados</emphasis> como <emphasis>sesión-por-transacción-de-aplicación</emphasis>, ambas tienen ventajas y desventajas, las discutimos más adelante en este capítulo en el contexto del control optimista de concurrencia."
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "Considerando la identidad del objeto"
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr "Una aplicación puede acceder concurrentemente a el mismo estado persistente en dos <literal>Session</literal>s diferentes. Sin embargo, una instancia de una clase persistente nunca se comparte entre dos instancias de <literal>Session</literal>. Por lo tanto existen dos nociones diferentes de identidad:"
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr "Identidad de Base de Datos"
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr "foo.getId().equals( bar.getId() )"
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr "Identidad JVM"
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr "foo==bar"
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr "Entonces para objetos unidos a una <literal>Session</literal> <emphasis>en particular</emphasis> (es decir en el ámbito de una <literal>Session</literal>) las dos nociones son equivalentes, y la identidad JVM para la identidad de base de datos está garantizada por Hibernate. Sin embargo, mientras la aplicación acceda concurrentemente al \"mismo\" (identidad persistente) objeto de negocio en dos sesiones diferentes, las dos instancias serán realmente \"diferentes\" (identidad JVM). Los conflictos se resuelven (con versionado automático) en tiempo de limpieza (flush) usando un enfoque optimista."
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr "Este enfoque deja que Hibernate y la base de datos se preocupen sobre la concurrencia. Además provee la mejor escalabilidad, ya que garantizando la identidad un unidades de trabajo monohebra no se necesitan bloqueos caros u otros medios de sincronización. La aplicación nunca necesita sincronizar sobre ningún objeto de negocio, siempre que se apegue a una sola hebra por <literal>Session</literal>. Dentro de una <literal>Session</literal> la aplicación puede usar con seguridad <literal>==</literal> para comparar objetos."
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr "Sin embargo, una aplicación que usa <literal>==</literal> fuera de una <literal>Session</literal>, podría ver resultados inesperados. Esto podría ocurrir incluso en sitios algo inesperados, por ejemplo, si pones dos instancias separadas dentro del mismo <literal>Set</literal>. Ambas podrían tener la misma identidad de base de datos (es decir, representar la misma fila), pero la identidad JVM, por definición, no está garantizada para las instancias en estado separado. El desarrollador tiene que sobrescribir los métodos <literal>equals()</literal> y <literal>hashCode()</literal> en las clases persistentes e implementar su propia noción de igualdad de objetos. Hay una advertencia: Nunca uses el identificador de base de datos para implementar la igualdad, usa una clave de negocio, una combinación de atributos únicos, usualmente inmutables. El identificador de base de datos cambiará si un objeto!
transitorio es hecho persistente. Si la instancia transitoria (usualmente junta a instancias separadas) es mantenida en un <literal>Set</literal>, cambiar el código hash rompe el contrato del <literal>Set</literal>. Los atributos para las claves de negocio no tienen que ser tan estables como las claves primarias de base de datos, sólo tienes que garantizar estabilidad en tanto los objetos estén en el mismo <literal>Set</literal>. Mira el sitio web de Hibernate para una discusión más cuidadosa de este tema. Nota también que éste no es un tema de Hibernate, sino simplemente cómo la identidad y la igualdad de los objetos Java tiene que ser implementada."
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr "Temas comunes"
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr "Nunca uses los antipatrones <emphasis>sesión-por-sesión-de-usuario</emphasis> o <emphasis>sesión-por-aplicación</emphasis> (por supuesto, hay raras excepciones a esta regla). Nota que algunis de los siguientes temas podrían también aparecer con los patrones recomendados. Asegúrate que entiendes las implicaciones antes de tomar una decisión de diseño:"
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "Una <literal>Session</literal> no es segura entre hebras. Las cosas que se suponen que funcionan concurrentemente, como peticiones HTTP, beans de sesión, o workers de Swing, provocarán condiciones de competencia si una instancia de <literal>Session</literal> fuese compartida. Si guardas tu <literal>Session</literal> de Hibernate en tu <literal>HttpSession</literal> (discutido más adelante), debes considerar sincronizar el acceso a tu sesión HTTP. De otro modo, un usuario que hace click lo suficientemente rápido puede llegar a usar la misma <literal>Session</literal> en dos hebras ejecutándose concurrentemente."
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr "Una excepción lanzada por Hibernate significa que tienes que deshacer (rollback) tu transacción de base de datos y cerrar la <literal>Session</literal> inmediatamente (discutido en más detalle luego). Si tu <literal>Session</literal> está ligada a la aplicación, tienes que parar la aplicación. Deshacer (rollback) la transacción de base de datos no pone a tus objetos de vuelta al estado en que estaban al comienzo de la transacción. Esto significa que el estado de la base de datos y los objetos de negocio quedan fuera de sincronía. Usualmente esto no es un problema, pues las excepciones no son recuperables y tienes que volver a comenzar después del rollback de todos modos."
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr "La <literal>Session</literal> pone en caché todo objeto que esté en estado persistente (vigilado y chequeado por estado sucio por Hibernate). Esto significa que crece sin fin hasta que obtienes una OutOfMemoryException, si la mantienes abierta por un largo tiempo o simplemente cargas demasiados datos. Una solución para esto es llamar a <literal>clear()</literal> y <literal>evict()</literal> para gestionar el caché de la <literal>Session</literal>, pero probalemente debas considerar un procedimiento almacenado si necesitas operaciones de datos masivas. Se muestran algunas soluciones en <xref linkend=\"batch\"/>. Mantener una <literal>Session</literal> abierta por la duración de una sesión de usuario significa también una alta probabilidad de datos añejos."
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "Demarcación de la transacción de base de datos"
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr "Los límites de las transacciones de base de datos (o sistema) son siempre necesarios. Ninguna comunicación con la base de datos puede darse fuera de una transacción de base de datos (esto parece confundir muchos desarrolladores acostumbrados al modo auto-commit). Siempre usa límites de transacción claros, incluso para las operaciones de sólo lectura. Dependiendo del nivel de aislamiento y las capacidades de base de datos, esto podría o no ser requerido, pero no hay un merma si siempre demarcas explícitamente las transacciones."
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr "Una aplicación Hibernate puede ejecutarse en entornos no manejados (es decir, como independiente, Web simple, o aplicaciones Swing) y entornos manejados J2EE. En un entorno no manejado, Hibernate es usualmente responsable de su propio pool de conexiones de base de datos. El desarrollador de aplicaciones tiene que establecer manualmente los límites de transacción, en otras palabras, hacer begin, commit, o rollback las transacciones de base de datos por sí mismo. Un entorno manejado usualmente provee transacciones gestionadas por contenedor, con el ensamble de transacción definido declarativamente en descriptores de despliegue de beans de sesión EJB, por ejemplo. La demarcación programática de transacciones no es más necesario, incluso limpiar (flush) la <literal>Session</literal> es hecho automáticamente."
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr "Sin embargo, frecuentemente es deseable mantener portable tu capa de persistencia. Hibernate ofrece una API de envoltura llamada <literal>Transaction</literal> que se traduce al sistema de transacciones nativo de tu entorno de despliegue. Esta API es realmente opcional, pero recomendamos fuertemente su uso salvo que estés en un bean de sesión CMT."
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "Usualmente, finalizar una <literal>Session</literal> implica cuatro fases distintas:"
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr "limpiar (flush) la sesión"
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "comprometer la transacción"
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr "cerrar la sesión"
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr "manejar excepciones"
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr "Limpiar la sesión ha sido discutido anteriormente, tendremos ahora una mirada más de cerca a la demarcación de transacciones y manejo de excepciones en sendos entornos manejado y no manejados."
+
+#: index.docbook:395
+msgid "close the session"
+msgstr "Entorno no manejado"
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr "Si una capa de persistencia Hibernate se ejecuta en un entorno no manejado, las conexiones de base de datos son manejadas usualmente por el mecanismo de pooling de Hibernate. El idioma manejo de sesión/transacción se ve así:"
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr ""
+ "<![CDATA[//Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr "No tienes que limpiar con <literal>flush()</literal> la <literal>Session</literal> explícitamente - la llamada a <literal>commit()</literal> automáticamente dispara la sincronización."
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "Una llamada a <literal>close()</literal> marca el fin de una sesión. La principal implicación de <literal>close()</literal> es que la conexión JDBC será abandonada por la sesión."
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "Este código Java es portable y se ejecuta tanto en entornos no manejados como en entornos JTA."
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr "Muy probablemente nunca veas este idioma en código de negocio en una aplicación normal; las excepciones fatales (sistema) deben siempre ser capturadas en la \"cima\". En otras palabras, el código que ejecuta las llamadas de Hibernate (en la capa de persistencia) y el código que maneja <literal>RuntimeException</literal> (y usualmente sólo puede limpiar y salir) están en capas diferentes. Esto puede ser un desafío de diseñarlo tú mismo y debes usar los servicios de contenedor J2EE/EJB en cuanto estuviesen disponibles. El manejo de excepciones se dicute más adelante en este capítulo."
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr "Nota que debes seleccionar <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (que es el por defecto)."
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr "Usando JTA"
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr "Si tu capa de persistencia se ejecuta en un servidor de aplicaciones (por ejemplo, detrás de beans de sesión EJB), cada conexión de datasource obtenida por Hibernate será parte automáticamente de la transacción JTA global. Hibernate ofrece dos estrategias para esta integración."
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "Si usas transacciones gestionadas-por-bean (BMT) Hibernate le dirá al servidor de aplicaciones que comience y finalice una transacción BMT si usas la API de <literal>Transaction</literal>. De modo que, el código de gestión de la transacción es idéntico al de un entorno no manejado."
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "Con CMT, la demarcación de la transacción se hace en descriptores de despliegue de beans de sesión, no programáticamente. Si no quieres limpiar (flush) y cerrar manualmente la <literal>Session</literal> por ti mismo, solamente establece <literal>hibernate.transaction.flush_before_completion</literal> a <literal>true</literal>, <literal>hibernate.connection.release_mode</literal> a <literal>after_statement</literal> o <literal>auto</literal> y <literal>hibernate.transaction.auto_close_session</literal> a <literal>true</literal>. Hibernate limpiará y cerrará entonces automáticamente la <literal>Session</literal> para ti. Lo único que resta es deshacer (rollback) la transacción cuando ocurra una excepción. Afortunadamente, en un bean CMT, incluso esto ocurre automáticamente, ya que una <literal>RuntimeException</literal> no manejada disparada por un método de un bean de sesión le!
dice al contenedor que ponga a deshacer la transacción global. <emphasis>Esto significa que, en CMT, no necesitas usar en absoluto la API de <literal>Transaction</literal> de Hibernate.</emphasis>"
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr "Nota que debes elegir <literal>org.hibernate.transaction.JTATransactionFactory</literal> en un bean de sesión BMT, y <literal>org.hibernate.transaction.CMTTransactionFactory</literal> en un bean de sesión CMT, cuando configures la fábrica de transacciones de Hibernate. Recuerda además establecer <literal>org.hibernate.transaction.manager_lookup_class</literal>."
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "Si trabajas en un entorno CMT, y usas limpieza (flushing) y cierre automáticos de la sesión, podrías querer también usar la misma sesión en diferentes partes de tu código. Típicamente, en un entorno no manejado, usarías una variable <literal>ThreadLocal</literal> para tener la sesión, pero una sola petición de EJB puede ejecutarse en diferentes hebras (por ejemplo, un bean de sesión llamando a otro bean de sesión). Si no quieres molestarte en pasar tu <literal>Session</literal> por alrededor, la <literal>SessionFactory</literal> provee el método <literal>getCurrentSession()</literal>, que devuelve una sesión que está pegada al contexto de transacción JTA. ¡Esta es la forma más fácil de integrar Hibernate en una aplicación! La sesión \"actual\" siempre tiene habilitados limpieza, cierre y liberación de conexió!
;n automáticos (sin importar la configuración de las propiedades anteriores). Nuestra idioma de gestión de sesión/transacción se reduce a:"
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr ""
+ "<![CDATA[// CMT idiom\n"
+ "Session sess = factory.getCurrentSession();\n"
+ "\n"
+ "// do some work\n"
+ "...\n"
+ "\n"
+ "]]>"
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr "En otras palabras, todo lo que tienes que hacer en un entorno manejado, es llamar a <literal>SessionFactory.getCurrentSession()</literal>, hacer tu trabajo de acceso a datos, y dejar el resto al contenedor. Los límites de transacción se establecen declarativamente en los descriptores de despliegue de tu bean de sesión. El ciclo de vida de la sesión es manejado completamente por Hibernate."
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr "Existe una advertencia al uso del modo de liberación de conexión <literal>after_statement</literal>. Debido a una limitación tonta de la especificación de JTA, no es posible para Hibernate limpiar automáticamente ningún <literal>ScrollableResults</literal> no cerrado ni instancias de <literal>Iterator</literal> devueltas por <literal>scroll()</literal> o <literal>iterate()</literal>. <emphasis>Debes</emphasis> liberar el cursor de base de datos subyacente llamando a <literal>ScrollableResults.close()</literal> o <literal>Hibernate.close(Iterator)</literal> explícitamente desde un bloque <literal>finally</literal>. (Por supuesto, la mayoría de las aplicaciones pueden evitarlo fácilmente no usando en absoluto ningún <literal>scroll()</literal> o <literal>iterate()</literal> desde el código CMT.)"
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr "Manejo de excepciones"
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr "Si la <literal>Session</literal> lanza una excepción (incluyendo cualquier <literal>SQLException</literal>), debes inmediatamente deshacer (rollback) la transacción de base de datos, llamar a <literal>Session.close()</literal> y descartar la instancia de <literal>Session</literal>. Ciertos métodos de <literal>Session</literal> <emphasis>no</emphasis> dejarán la sesión en un estado consistente. Ninguna excepción lanzada por Hibernate puede ser tratada como recuperable. Asegúrate que la <literal>Session</literal> sea cerrada llamando a <literal>close()</literal> en un bloque <literal>finally</literal>."
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr "La <literal>HibernateException</literal>, que envuelve la mayoría de los errores que pueden ocurrir en la capa de persistencia de Hibernate, en una excepción no chequeada (no lo era en versiones anteriores de Hibernate). En nuestra opinión, no debemos forzar al desarrollador de aplicaciones a capturar una excepción irrecuperable en una capa baja. En la mayoría de los sistemas, las excepciones no chequeadas y fatales son manejadas en uno de los primeros cuadros de la pila de llamadas a métodos (es decir, en las capas más altas) y se presenta un mensaje de error al usuario de la aplicación (o se toma alguna otra acción apropiada). Nota que Hibernate podría también lanzar otras excepciones no chequeadas que no sean una <literal>HibernateException</literal>. Una vez más, no son recuperables y debe tomarse una acción apropiada."
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr "Hibernate envuelve <literal>SQLException</literal>s lanzadas mientras se interactúa con la base de datos en una <literal>JDBCException</literal>. De hecho, Hibernate intentará convertir la excepción en una subclase de <literal>JDBCException</literal> más significativa. La <literal>SQLException</literal> está siempre disponible vía <literal>JDBCException.getCause()</literal>. Hibernate convierte la <literal>SQLException</literal> en una subclase de <literal>JDBCException</literal> apropiada usando el <literal>SQLExceptionConverter</literal> adjunto a la <literal>SessionFactory</literal>. Por defecto, el <literal>SQLExceptionConverter</literal> está definido para el dialecto configurado; sin embargo, es también posible enchufar una implementación personalizada (ver los javadocs de la clase <literal>SQLExceptionConverterFactory</literal> para los detalles). Los subtipos estándar de <literal>JDBCExcep!
tion</literal> son:"
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr "<literal>JDBCConnectionException</literal> - indica un error con la comunicación JDBC subyacente."
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "<literal>SQLGrammarException</literal> - indica un problema de gramática o sintáxis con el SQL publicado."
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr "<literal>ConstraintViolationException</literal> - indica alguna forma de violación de restricción de integridad."
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "<literal>LockAcquisitionException</literal> - indica un error adquiriendo un nivel de bloqueo necesario para realizar una operación solicitada."
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr "<literal>GenericJDBCException</literal> - una excepción genérica que no cayó en ninguna de las otras categorías."
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr "Control optimista de concurrencia"
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr "El único enfoque que es consistente con alta concurrencia y alta escalabilidad es el control optimista de concurrencia con versionamiento. El chuequeo de versión usa números de versión, o timestamps, para detectar actualizaciones en conflicto (y para prevenir actualizaciones perdidas). Hibernate provee para tres enfoques posibles de escribir código de aplicación que use concurrencia optimista. Los casos de uso que hemos mostrado están en el contexto de transacciones de aplicación largas pero el chequeo de versiones tiene además el beneficio de prevenir actualizaciones perdidas en transacciones de base de datos solas."
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "Chequeo de versiones de aplicación"
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr "En una implementación sin mucha ayuda de Hibernate, cada interacción con la base de datos ocurre en una nueva <literal>Session</literal> y el desarrollador es responsable de recargar todas las intancias persistentes desde la base de datos antes de manipularlas. Este enfoque fuerza a la aplicación a realizar su propio chequeo de versiones para asegurar el aislamiento de transacciones de base de datos. Es el enfoque más similar a los EJBs de entidad."
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "La propiedad <literal>version</literal> se mapea usando <literal><version></literal>, e Hibernate la incrementará automáticamente durante la limpieza si la entidad está sucia."
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "Por supuesto, si estás operando un entorno de baja-concurrencia-de-datos y no requieres chequeo de versiones, puedes usar este enfoque y simplemente saltar el chequeo de versiones. En ese caso, <emphasis>el último compromiso (commit) gana</emphasis> será la estrategia por defecto para tus transacciones de aplicación largas. Ten en mente que esto podría confundir a los usuarios de la aplicación, pues podrían experimentar actualizaciones perdidas sin mensajes de error ni chance de fusionar los cambios conflictivos."
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr "Claramente, el chequeo manual de versiones es factible solamente en circunstancias muy triviales, y no es práctico para la mayoría de aplicaciones. Frecuentemente, no sólo intancias solas, sino grafos completos de objetos modificados tienen que ser chequeados. Hibernate ofrece chequeo de versiones automático con el paradigma de diseño de <literal>Session</literal> larga o de instancias separadas."
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr "Sesión larga y versionado automático"
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "Una sola instancia de <literal>Session</literal> y sus instancias persistentes son usadas para toda la transacción de aplicación. Hibernate chequea las versiones de instancia en el momento de limpieza (flush), lanzando una excepción si se detecta una modificación concurrente. Concierne al desarrollador capturar y manejar esta excepción (las opciones comunes son la oportunidad del usuario de fusionar los cambios, o recomenzar el proceso de negocio sin datos añejos)."
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr "La <literal>Session</literal> se desconecta de cualquier conexión JDBC subyacente al esperar por una interacción del usuario. Este enfoque es el más eficiente en términos de acceso a base de datos. La aplicación no necesita tratar por sí misma con el chequeo de versiones, ni re-uniendo instancias separadas, ni tiene que recargar instancias en cada transacción de base de datos."
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr ""
+ "<![CDATA[// foo is an instance loaded earlier by the Session\n"
+ "session.reconnect(); // Obtain a new JDBC connection\n"
+ "Transaction t = session.beginTransaction();\n"
+ "foo.setProperty(\"bar\");\n"
+ "t.commit(); // End database transaction, flushing the change and checking the version\n"
+ "session.disconnect(); // Return JDBC connection ]]>"
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr "El objeto <literal>foo</literal> todavía conoce en qué <literal>Session</literal> fue cargado. <literal>Session.reconnect()</literal> obtiene una nueva conexión (o puedes proveer una) y reasume la sesión. El método <literal>Session.disconnect()</literal> desconectará la sesión de la conexión JDBC y la devolverá la conexión al pool (a menos que hayas provisto la conexión). Después de la reconexión, para forzar un chequeo de versión en datos que no estés actualizando, puedes llamar a <literal>Session.lock()</literal> con <literal>LockMode.READ</literal> sobre cualquier objeto que pudiese haber sido actualizado por otra transacción. No necesitas bloquear ningún dato que <emphasis>sí estés</emphasis> actualizando."
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr "Si las llamadas explícitas a <literal>disconnect()</literal> y <literal>reconnect()</literal> son muy onerosas, puedes usar en cambio <literal>hibernate.connection.release_mode</literal>."
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "Este patrón es problemático si la <literal>Session</literal> es demasiado grande para ser almacenada durante el tiempo de pensar del usuario, por ejemplo, una <literal>HttpSession</literal> debe mantenerse tan pequeña como sea posible. Ya que la <literal>Session</literal> es también el caché (obligatorio) de primer nivel y contiene todos los objetos cargados, podemos probablemente cargar esta estrategia sólo para unos pocos ciclos petición/respuesta. Esto está de hecho recomendado, ya que la <literal>Session</literal> tendrá pronto también datos añejos."
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "Nota también que debes mantener la <literal>Session</literal> desconectada próxima a la capa de persistencia. En otras palabras, usa una sesión de EJB con estado para tener la <literal>Session</literal> y no transferirla a la capa web para almacenarla en la <literal>HttpSession</literal> (ni incluso serializarla a una capa separada)."
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr "Objetos separados y versionado automático"
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr "Cada interacción con el almacén persistente ocurre en una nueva <literal>Session</literal>. Sin embargo, las mismas instancias persistentes son reusadas para cada interacción con la base de datos. La aplicación manipula el estado de las instancias separadas originalmente cargadas en otra <literal>Session</literal> y luego las readjunta usando <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, o <literal>Session.merge()</literal>."
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr "De nuevo, Hibernate chequeará las versiones de instancia durante la limpieza (flush), lanzando una excepción si ocurrieron actualizaciones en conflicto."
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr "Puedes también llamar a <literal>lock()</literal> en vez de <literal>update()</literal> y usar <literal>LockMode.READ</literal> (realizando un chequeo de versión, puenteando todos los cachés) si estás seguro que el objeto no ha sido modificado."
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr "Personalizando el versionado automático"
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr "Puedes deshabilitar el incremento de versión automático de Hibernate para propiedades en particular y colecciones estableciendo el atributo de mapeo <literal>optimistic-lock</literal> a <literal>false</literal>. Hibernate entonces no incrementará ya más las versiones si la propiedad está sucia."
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr "Los esquemas de base de datos heredados son frecuentemente estáticos y no pueden ser modificados. U otras aplicaciones podrían también acceder la misma base de datos y no saber cómo manejar los números de versión ni incluso timestamps. En ambos casos, el versionado no puede confiarse a una columna en particular en una tabla. Para forzar un chequeo de versiones sin un mapeo de propiedad de versión o timestamp, con una comparación del estado de todos los campos en una fila, activa <literal>optimistic-lock=\"all\"</literal> en el mapeo de <literal><class></literal>. Nota que esto conceptualmente funciona solamente si Hibernate puede comparar el estado viejo y nuevo, es decir, si usas una sola <literal>Session</literal> larga y no sesión-por-petición-con-instancias-separadas."
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr "A veces las modificaciones concurrentes pueden permitirse, en cuanto los cambios que hayan sido hechos no se traslapen. Si estableces <literal>optimistic-lock=\"dirty\"</literal> al mapear la <literal><class></literal>, Hibernate sólo comparará los campos sucios durante la limpieza."
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr "En ambos casos, con columnas de versión/timestamp dedicadas o con comparación de campos completa/sucios, Hibernate usa una sola sentencia <literal>UPDATE</literal> (con una cláusula <literal>WHERE</literal> apropiada) por entidad para ejecutar el chequeo de versiones y actualizar la información. Si usas persistencia transitiva para la re-unión en cascada de entidades asociadas, Hibernate podría ejecutar actualizaciones innecesarias. Esto usualmente no es un problema, pero podrían ejecutarse disparadores (triggers) <emphasis>on update</emphasis> en la base de datos incluso cuando no se haya hecho ningún cambio a las instancias separadas. Puedes personalizar este comportamiento estableciendo <literal>select-before-update=\"true\"</literal> en el mapeo de <literal><class></literal>, forzando a Hibernate a <literal>SELECT</literal> la instancia para asegurar que las actualizaciones realmente ocurran, antes de!
actualizar la fila."
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr "Bloqueo pesimista"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr "No se pretende que los usuarios gasten mucho tiempo preocupándose de las estrategias de bloqueo. Usualmente es suficiente con especificar un nivel de aislamiento para las conexiones JDBC y entonces simplemente dejar que la base de datos haga todo el trabajo. Sin embargo, los usuarios avanzados pueden a veces obtener bloqueos exclusivos pesimistas, o reobtener bloqueos al comienzo de una nueva transacción."
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr "¡Hibernate siempre usará el mecanismo de bloqueo de la base de datos, nunca bloqueo de objetos en memoria!"
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr "La clase <literal>LockMode</literal> define los diferentes niveles de bloqueo que pueden ser adquiridos por Hibernate. Un bloqueo se obtiene por los siguientes mecanismos:"
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr "<literal>LockMode.WRITE</literal> se adquiere automáticamente cuando Hibernate actualiza o inserta una fila."
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "<literal>LockMode.UPGRADE</literal> puede ser adquirido bajo petición explícita del usuario usando <literal>SELECT ... FOR UPDATE</literal> en base de datos que soporten esa sintáxis."
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr "<literal>LockMode.UPGRADE_NOWAIT</literal> puede ser adquirido bajo petición explícita del usuario usando un <literal>SELECT ... FOR UPDATE NOWAIT</literal> bajo Oracle."
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr "<literal>LockMode.READ</literal> es adquirido automáticamente cuando Hibernate lee datos bajo los niveles de aislamiento Repeatable Read o Serializable. Puede ser readquirido por pedido explícito del usuario."
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr "<literal>LockMode.NONE</literal> representa la ausencia de un bloqueo. Todos los objetos se pasan a este modo de bloqueo al final de una <literal>Transaction</literal>. Los objetos asociados con una sesión vía una llamada a <literal>update()</literal> o <literal>saveOrUpdate()</literal> también comienzan en este modo de bloqueo."
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr "La \"petición explícita del usuario\" se expresa en una de las siguientes formas:"
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr "Una llamada a <literal>Session.load()</literal>, especificando un <literal>LockMode</literal>."
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr "Una llamada a <literal>Session.lock()</literal>."
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "Una llamada a <literal>Query.setLockMode()</literal>."
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "Si se llama a <literal>Session.load()</literal> con <literal>UPGRADE</literal> o <literal>UPGRADE_NOWAIT</literal>, y el objeto pedido no ha sido aún cargado por la sesión, el objeto es cargado usando <literal>SELECT ... FOR UPDATE</literal>. Si se llama a <literal>load()</literal> para un objeto que ya esté cargado con un bloqueo menos restrictivo que el pedido, Hibernate llama a <literal>lock()</literal> para ese objeto."
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "<literal>Session.lock()</literal> realiza un chequeo de número de versión si el modo de bloqueo especificado es <literal>READ</literal>, <literal>UPGRADE</literal> o <literal>UPGRADE_NOWAIT</literal>. (En el caso de <literal>UPGRADE</literal> o <literal>UPGRADE_NOWAIT</literal>, se usa <literal>SELECT ... FOR UPDATE</literal>.)"
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "Si la base de datos no soporta el modo de bloqueo solicitado, Hibernate usará un modo alternativo apropiado (en vez de lanzar una excepción). Esto asegura que las aplicaciones serán portables."
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr ""
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr ""
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr ""
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr ""
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr ""
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr ""
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr ""
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr ""
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr ""
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr ""
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr ""
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr ""
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr ""
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr ""
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr ""
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr ""
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr ""
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr ""
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1747 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr "Introducción a Hibernate"
+
+#: index.docbook:10
+msgid "Preface"
+msgstr "Prefacio"
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr "Este capítulo es un tutorial introductorio de Hibernate. Comenzamos con una aplicación simple de línea de comandos usando un base de datos en-memoria y desarrollándola en fácil para entender los pasos."
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr "Este tutorial está concebido para usuarios nuevos de Hibernate pero requiere conocimiento en Java y SQL. Está basado en un tutorial de Michael Gloegl. Las bibliotecas de terceros que mencionamos son para JDK 1.4 y 5.0. Podrías necesitar otras para JDK 1.3."
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "Parte 1 - La primera Aplicación Hibernate"
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr "Primero, crearemos una aplicación simple de Hibenate basada en consola. Usamos usamos una base de datos en-memoria (HSQL DB), de modo que no necesitamos instalar ningún servidor de base de datos."
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr "Asumamos que necesitamos una aplicación pequeña de base de datos que pueda almacenar eventos que queremos atender, e información acerca de los hostales de estos eventos."
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr "La primera cosa que hacemos, es armar nuestro directorio de desarrollo y poner en él todas las bibliotecas Java que necesitamos. Descarga la distribución de Hibernate del sitio web de Hibernate. Extrae el paquete y coloca todas las bibliotecas requeridas encontradas en <literal>/lib</literal> dentro del directorio <literal>/lib</literal> de nuestro nuevo directorio de desarrollo de trabajo. Debe asemejarse a esto:"
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib-full.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " ehcache.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr "Este es el conjunto mínimo de bibliotecas requeridas para Hibernate (observa que también hemos copiado hibernate3.jar, el fichero principal). Ver el fichero <literal>README.txt</literal> en el directorio <literal>lib/</literal> de la distribución de Hibernate para más información sobre bibliotecas de terceros requeridas y opcionales. (Realmente, Log4J no es requerida aunque preferida por muchos desarrolladores)."
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr "Por siguiente, creamos una clase que represente el evento que queremos almacenar en base de datos."
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr "La primera clase"
+
+#: index.docbook:68
+msgid "The first class"
+msgstr "Nuestra primera clase persistente es un JavaBean simple con algunas propiedades:"
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr ""
+ "<![CDATA[import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr "Puedes ver que esta clase usa las convenciones de nombrado estándar de JavaBean para métodos getter y setter de propiedad, así como visibilidad privada para los campos. Esto es un diseño recomendado, aunque no requerido. Hibernate también puede acceder a los campos directamente; el beneficio de los métodos de acceso es la robustez para la refactorización."
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr "La propiedad <literal>id</literal> tiene un valor único de identificador para un evento en particular. Todas las clase de entidad persistentes ( también hay clases dependientes menos importantes) necesitarán una propiedad identificadora similar si queremos usar el conjunto completo de funcionalidades de Hibernate. De hecho, la mayoría de las aplicaciones (esp. aplicaciones web) necesitan distinguir objetos por identificador, de modo que debes considerar esto como un aspecto en vez de una limitación. Sin embargo, usualmente no manipulamos la identidad de un objeto, por lo tanto el método setter debe ser privado. Sólo Hibernate asignará identificadores cuando un objeto sea salvado. Puedes ver que Hibernate puede acceder a métodos de acceso públicos, privados y protegidos, tanto como directamente a campos (públicos, privados y protegidos). La elección está en ti, y puedes ajustar!
la a tu diseño de aplicación."
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr "El constructor sin argumentos es un requerimiento para todas las clases persistentes. Hibernate tiene que crear objetos para ti, usando reflección Java. El constructor puede ser privado, sin embargo, la visibilidad de paquete es requerida para la generación de proxies en tiempo de ejecución y la recuperación de datos sin instrumentación del bytecode."
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr "Coloca este fichero de código Java en un directorio llamado <literal>src</literal> en la carpeta de desarrollo. El directorio ahora debe verse como esto:"
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " Event.java]]>"
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr "En el próximo paso, le decimos a Hibernate sobre esta clase persistente."
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr "El fichero de mapeo"
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr "Hibernate necesita saber cómo cargar y almacenar objetos de la clase persistente. Aquí es donde el fichero de mapeo de Hibernate entra en juego. El fichero de mapeo le dice a Hibernate a qué tabla en la base de datos tiene que acceder, y qué columnas en esta tabla debe usar."
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr "La estructura básica de un fichero de mapeo se parece a esto:"
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr "Observa que el DTD de Hibernate es muy sofisticado. Puedes usarlo para autocompleción de los elementos y atributos XML de mapeo en tu editor o IDE. Debes también abrir el fichero DTD en tu editor de texto. Es la forma más fácil para tener un panorama de todos los elementos y atributos y ver los valores por defectos, así como algunos comentarios. Nota que Hibernate no cargará el fichero DTD de la web, sino que primero buscará en el classpath de la aplicación. El fichero DTD está incluído en <literal>hibernate3.jar</literal> así como también en el directorio <literal>src/</literal> de la distribución de Hibernate."
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr "Omitiremos la declaración de DTD en futuros ejemplos para acortar el código. Por supuesto, no es opcional."
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr "Entre las dos etiquetas <literal>hibernate-mapping</literal>, incluye un elemento <literal>class</literal>. Todas las clases de entidad persistentes (de nuevo, podría haber más adelante clases dependientes, que no sean entidades de-primera-clase) necesitan dicho mapeo a una tabla en la base de datos SQL:"
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Hasta ahora dijimos a Hibernate cómo persistir y cargar el objeto de clase <literal>Event</literal> a la tabla <literal>EVENTS</literal>, cada instancia representada por una fila en esta tabla. Ahora continuamos con un mapeo de la propiedad de identificado único a la clave primaria de la tabla. Además, como no queremos cuidar del manejo de este identificador, configuramos la estrategia de generación de identificadores para una columna clave primaria delegada:"
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "El elemento <literal>id</literal> el la declaración de la propiedad identificadora, <literal>name=\"id\"</literal> declara el nombre de la propiedad Java. Hibernate usará los métodos getter y setter para acceder a la propiedad. El attributo de columna dice a Hibernate cuál columna de la tabla <literal>EVENTS</literal> usamos para esta clave primaria. El elemento anidado <literal>generator</literal> especifica la estrategia de generación de identificadores, en este caso usamos <literal>increment</literal>, que es un método muy simple de incremento de número en-memoria útil mayormente para testeo (y tutoriales). Hibernate también soporta identificadores generados por base de datos, globalmente únicos, así como también asignados por aplicación (o cualquier estrategia para la que hayas escrito una extensión)."
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr "Finalmente incluímos declaraciones para las propiedades persistentes de la clases en el fichero de mapeo. Por defecto, ninguna propiedad de la clase se considera persistente:"
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Al igual que con el elemento <literal>id</literal>, el atributo <literal>name</literal> del elemento <literal>property</literal> dice a Hibernate cáles métodos getter y setter usar."
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr "¿Por qué el mapeo de la propiedad <literal>date</literal> incluye el atributo <literal>column</literal>, pero el de la de <literal>title</literal> no? Sin el atributo <literal>column</literal> Hibernate usa por defecto el nombre de propiedad como nombre de columna. Esto funciona bien para <literal>title</literal>. Sin embargo, However, <literal>date</literal> es una palabra reservada en la mayoría de las bases de datos, así que mejor la mapeamos a un nombre diferente."
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr "La próxima cosa interesante es que el mapeo de <literal>title</literal> carece de un atributo <literal>type</literal>. Los tipos que declaramos y usamos en el fichero de mapeo no son, como podrías esperar, tipos de datos Java. Tampoco son tipos de base de datos SQL. Estos tipos son los llamados así <emphasis>Tipos de mapeo de Hibernate</emphasis>, convertidores que pueden traducir de tipos Java a SQL y vice versa. De nuevo, Hibernate intentará determinar la conversión y el mapeo mismo de tipo correctos si el atributo <literal>type</literal> no estuviese presente en el mapeo. En algunos casos esta detección automática (usando reflección en la clase Java) puede no tener lo que esperas o necesitas. Este es el caso de la propiedad <literal>date</literal>. Hibernate no puede saber is la propiedad mapeará a una columna <literal>date</literal>, <literal>timestamp</literal> o <literal>time</literal>. Declaramos !
que queremos preservar la información completa de fecha y hora mapeando la propiedad con un <literal>timestamp</literal>."
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr "Este fichero de mapeo debe ser salvado como <literal>Event.hbm.xml</literal>, justo en el directorio próximo al fichero de código fuente de la clase Java <literal>Event</literal>. El nombrado de los ficheros de mapeo puede ser arbitrario, sin embargo, el sufijo <literal>hbm.xml</literal> se ha vuelto una convención el la comunidad de desarrolladores de Hibernate. La estructura de directorio debe ahora verse como esto:"
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr "Continuamos con la configuración principal de Hibernate."
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr "Configuración de Hibernate"
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr "Tenemos ahora una clase persistente y su fichero de mapeo en su sitio. Es momento de configurar Hibernate. Antes que hagamos esto, necesitaremos una base de datos. HSQL DB, un DBMS SQL en-memoria basado en Java, puede ser descargado del sitio web de HSQL DB. Realmente, de esta descarga sólo necesitas el <literal>hsqldb.jar</literal>. Coloca este fichero en el directorio <literal>lib/</literal> de la carpeta de desarrollo."
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr "Crea un directorio llamado <literal>data</literal> en la raíz del directorio de desarrollo. Allí es donde HSQL DB almacenará sus ficheros de datos."
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr "Hibernate es la capa en tu aplicación que se conecta a esta base de datos, de modo que necesita información de conexión. Las conexiones se hacen a través de un pool de conexiones JDBC, que tambén tenemos que configurar. La distribución de Hibernate contiene muchas herramientas de pooling de conexiones JDBC de código abierto, pero para este tutorial usaremos el pool de conexiones prefabricado dentro de Hibernate. Observa que tienes que copiar la biblioteca requerida en tu classpath y usar diferentes configuraciones de pooling de conexiones si quieres usar un software de pooling JDBC de terceros de calidad de producción."
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr "Para la configuración de Hibernate, podemos usar un fichero <literal>hibernate.properties</literal> simple, un fichero <literal>hibernate.cfg.xml</literal> ligeramente más sofisticado, o incluso una configuración completamente programática. La mayoría de los usuarios prefieren el fichero de configuración XML:"
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:data/tutorial</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr "Observa que esta configuración XML usa un DTD diferente. Configuramos la <literal>SessionFactory</literal> de Hibernate, una fábrica global responsable de una base de datos en particular. Si tienes varias bases de datos, usa varias configuraciones <literal><session-factory></literal> , usualmente en varios ficheros de configuración (para un arranque más fácil)."
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr "Los primeros cuatro elementos <literal>property</literal> contienen la configuración necesaria para la conexión JDBC. El elemento de dialecto <literal>property</literal> especifica la variante de SQL en particular que genera Hibernate. La opción <literal>hbm2ddl.auto</literal> activa la generación automática de esquemas de base de datos, directamente en la base de datos. Esto, por supuesto, puede desactivarse (quitando la opción config) o redirigido a un fichero con la ayuda de la tarea de Ant <literal>SchemaExport</literal>. Finalmente, agregamos el(los) fichero(s) de mapeo para clases persistentes."
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr "Copia este fichero dentro del directorio de código fuente, de modo que termine ubicado en la raiíz del classpath. Hibernate busca automáticamente un fichero llamado <literal>hibernate.cfg.xml</literal> en la raíz del classpath al arrancar."
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr "Construyendo con Ant"
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr "Construiremos ahora el tutorial con Ant. Necesitarás tener Ant instalado. Obténlo de <ulink url=\"http://ant.apache.org/bindownload.cgi\">Página de descarga de Ant</ulink>. No se cubrirá aquí cómo instalar Ant. Por favor refiérete al <ulink url=\"http://ant.apache.org/manual/index.html\"> Manual de Ant</ulink>. Después que hayas instalado Ant, podemos comenzar a crear el buildfile. Será llamado <literal>build.xml</literal> y colocado directamente en el directorio de desarrollo."
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr "Reparar Ant"
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr "Observa que la distribución de Ant está por defecto rota (como se describe en el FAQ de Ant) y tiene que ser reparado por ti, por ejemplo, si quisieras usar JUnit desde dentro de tu fichero de construcción. Para hacer que funcione la tarea de JUnit (no lo necesitaremos en este tutorial), copia junit.jar a <literal>ANT_HOME/lib</literal> o quita el trozo de plugin <literal>ANT_HOME/lib/ant-junit.jar</literal>."
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr "Un fichero de construcción básico se ve como esto:"
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr "Esto dirá a Ant que agregue todos los ficheros en el directorio lib que terminen con <literal>.jar</literal> al classpath usado para la compilación. También copiará todos los ficheros que no sean código Java al directorio objetivo, por ejemplo, ficheros de configuración y mapeos de Hibernate. Si ahora corres Ant, debes obtener esta salida:"
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr "Arranque y ayudantes"
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr "Es momento de cargar y almacenar algunos objetos <literal>Event</literal>, pero primero tenemos que completar la configuración de algún código de infraestructura. Tenemos que arrancar Hibernate. Este arranque incluye construir un objeto <literal>SessionFactory</literal> global y almacenarlo en algún sitio de fácil acceso en el código de aplicación. Una <literal>SessionFactory</literal> puede abrir nuevas <literal>Session</literal>'s. Una <literal>Session</literal> representa un unidad de trabajo mono-hebra. La <literal>SessionFactory</literal> es un objeto global seguro entre hebras, instanciado una sola vez."
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "Crearemos una clase de ayuda <literal>HibernateUtil</literal> que cuide del arranque y haga conveniente el manejo de <literal>Session</literal>. El así llamado patrón <emphasis>Sesión de Hebra Local (ThreadLocal Session)</emphasis> es útil aquí; mantenemos la unidad de trabajo actual asociada a la hebra actual. Echemos una mirada a la implementación:"
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr ""
+ "<![CDATA[import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " public static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static final ThreadLocal session = new ThreadLocal();\n"
+ "\n"
+ " public static Session currentSession() throws HibernateException {\n"
+ " Session s = (Session) session.get();\n"
+ " // Open a new Session, if this thread has none yet\n"
+ " if (s == null) {\n"
+ " s = sessionFactory.openSession();\n"
+ " // Store it in the ThreadLocal variable\n"
+ " session.set(s);\n"
+ " }\n"
+ " return s;\n"
+ " }\n"
+ "\n"
+ " public static void closeSession() throws HibernateException {\n"
+ " Session s = (Session) session.get();\n"
+ " if (s != null)\n"
+ " s.close();\n"
+ " session.set(null);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr "Esta clase no ólo produce la <literal>SessionFactory</literal> global en su inicializador static (llamado sólo una vez por la JVM al cargar la clase), sino que también tiene una variable <literal>ThreadLocal</literal> para tener la <literal>Session</literal> para la hebra actual. No importa cuándo llames a <literal>HibernateUtil.currentSession()</literal>, siempre devolverá la misma unidad de trabajo de Hibernate en la misma hebra. Una llamada a <literal>HibernateUtil.closeSession()</literal> termina la unidad de trabajo actualmente asociada a la hebra."
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr "Asegúrate de entender el concepto Java de una variable local a una hebra antes de usar esta ayuda. Una clase <literal>HibernateUtil</literal> más potente puede encontrarse en <literal>CaveatEmptor</literal>, http://caveatemptor.hibernate.org/, así como en el libro \"Java Persistence with Hibernate\". Observa que esta clase no es necesaria si despliegas Hibernate en un servidor de aplicaciones J2EE: una <literal>Session</literal> será automáticamente ligada a la transacción JTA actual, y puedes buscar la <literal>SessionFactory</literal> a través de JNDI. Si usas JBoss AS, Hibernate puede ser desplegado como un servicio de sistema manejado y automáticamente ligará la <literal>SessionFactory</literal> a un nombre JNDI."
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr "Coloca <literal>HibernateUtil.java</literal> en el directorio de fuentes de desarrollo, junto a <literal>Event.java</literal>:"
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr "Esto también debe compilar sin problemas. Finalmente necesitamos configurar un sistema de logging (registro). Hibernate usa commons logging y te deja la elección entre Log4J y logging de JDK 1.4. La mayoría de los desarrolladores prefieren Log4J: copia <literal>log4j.properties</literal> de la distribución de Hibernate (está en el directorio <literal>etc/</literal>) a tu directorio <literal>src</literal>, junto a <literal>hibernate.cfg.xml</literal>. Echa una mirada a la configuración de ejemplo y cambia los ajustes si te gusta tener una salida más verborrágica. Por defecto, sólo se muestra el mensaje de arranque de Hibernate en la salida."
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr "La infraestructura del tutorial está completa, y estamos listos para hacer algún trabajo real con Hibernate."
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr "Cargando y almacenando objetos"
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "Finalmente, podemos usar Hibernate para cargar y almacenar objetos. Escribimos una clase <literal>EventManager</literal> con un método <literal>main()</literal>:"
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr ""
+ "<![CDATA[import org.hibernate.Transaction;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.sessionFactory.close();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr "Leemos algunos argumentos de la línea de comandos, y si el primer argumento es \"store\", creamos y almacenamos un nuevo Event:"
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr ""
+ "<![CDATA[private void createAndStoreEvent(String title, Date theDate) {\n"
+ " Session session = HibernateUtil.currentSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " tx.commit();\n"
+ " HibernateUtil.closeSession();\n"
+ "}]]>"
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr "Creamos un nuevo objeto <literal>Event</literal>, y se lo damos a Hibernate. Hibernate cuida ahora del SQL y ejecuta <literal>INSERT</literal>s en la base de datos. Echemos una mirada al código de manejo de <literal>Session</literal> y <literal>Transaction</literal> antes de ejecutar esto."
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr "Una <literal>Session</literal> es una sola unidad de trabajo. Podría sorprenderte que tengamos una API adicional, <literal>Transaction</literal>. Esto implica que una unidad de trabajo puede ser \"más larga\" que una sola transacción de base de datos; imagina una unidad de trabajo que se abarca varios ciclos petición/respuesta HTTP (por ejemplo, un diálogo asistente) en una aplicación web. Separar las transacciones de base de datos de \"las unidades de trabajo de la aplicación desde el punto de vista del usuario\" es uno de los conceptos básicos de diseño de Hibernate. Llamamos una unidad de trabajo larga <emphasis>Transacción de Aplicación</emphasis>, usualmente encapsulando varias transacciones de base de datos más cortas. Por ahora mantendremos las cosas simples y asumiremos una granularidad uno-a-uno entre una <literal>Session</literal> y una <literal>Transaction</literal>."
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr "¿Qué es lo que hacen <literal>Transaction.begin()</literal> y <literal>commit()</literal>? ¿Dónde está el rollback en caso que algo vaya mal? La API de <literal>Transaction</literal> de Hibernate es opcional realmente, pero la usamos por conveniencia y portabilidad. Si manejases la transacción de base de datos por ti mismo (por ejemplo, llamando a <literal>session.connection.commit()</literal>), ligarías el código a un entorno de despliegue particular, en este JDBC directo no manejado. Estableciendo la fábrica de <literal>Transaction</literal> en tu configuración de Hibernate puedes desplegar tu capa de persistencia en cualquier sitio. Echa una mirada al <xref linkend=\"transactions\"/> para más información sobre manejo y demarcación de transacciones. Hemos saltado también cualquier manejo de excepciones y rollback en este ejemplo."
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr "Para ejecutar la primera rutina tenemos que agregar un objetivo llamable al fichero de construcción de Ant:"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr "El valor del argumento <literal>action</literal> es establecido por línea de comandos al llamar al objetivo:"
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr "Debes ver, después de la compilación, a Hibernate arrancando y, dependiendo de tu configuración mucha salida de registro (log). Al final encontrarás la siguiente línea:"
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr "Esta es la <literal>INSERT</literal> ejecutada por Hibernate, los signos de preguntas representan parámetros de ligado JDBC. Para ver los valores ligados como argumentos, o para reducir la verborragia del registro, chequea tu <literal>log4j.properties</literal>."
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr "Ahora quisiéramos listar acontecimientos almacenados también, así que agregamos una opción al método principal:"
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr "Agregamos también un nuevo método <literal>listEvents()</literal>:"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private List listEvents() {\n"
+ " Session session = HibernateUtil.currentSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " tx.commit();\n"
+ " session.close();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr "Lo que hacemos aquí es usar una consulta HQL (Lenguaje de Consulta de Hibernate o Hibernate Query Language) para cargar todos los objetos <literal>Event</literal> existentes de la base de datos. Hibernate generará el SQL apropiado, lo enviará a la base de datosy poblará los objetos <literal>Event</literal> con datos. Puedes, por supuesto, crear consultas más complejas con HQL."
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr "Si ahora llamas a Ant con <literal>-Daction=list</literal>, debes ver los eventos que has almacenado hasta ahora. Puede sorprenderte que esto no funcione, al menos si has seguido este tutorial paso por paso; el resultado siempre estará vacío. La razon de esto es la opción <literal>hbm2ddl.auto</literal> en la configuración de Hibernate: Hibernate recreará la base de datos en cada ejecución. Deshabilítala quitando la opción, y verás resultados en tu listado después que llames a la acción <literal>store</literal> unas cuantas veces. La generación y exportación de esquema es útil mayormente en testeo unitario."
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr "Part 2 - Mapeando asociaciones"
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr "Hemos mapeado un clase de entidad persistente a una tabla. Construyamos sobre esto y agreguemos algunas asociaciones de clase. Primero agregaremos personas a nuestra aplicación, y almacenaremos una lista de eventos en las que participan."
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr "Mapeando la clase Person"
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr "El primer corte de la clase <literal>Person</literal> es simple:"
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr "Crea un fichero de mapeo llamado <literal>Person.hbm.xml</literal>:"
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr "Finalmente, agrega el nuevo mapeo a la configuración de Hibernate:"
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[ <mapping resource=\"Event.hbm.xml\"/>\n"
+ " <mapping resource=\"Person.hbm.xml\"/>\n"
+ "]]>"
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr "Crearemos ahora una asociación entre estas dos entidades. Obviamente, las personas pueden participar en eventos, y los eventos tienen participantes. Las cuestiones de diseño con que tenemos que tratar son: direccionalidad, multiplicidad y comportamiento de colección."
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Una asociación unidireccional basada en Set"
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr "Agregaremos una colección de eventos a la clase <literal>Person</literal>. De esta forma podemos navegar facilmente a los eventos de una persona en particular, sin ejecutar una consulta explícita, llamando a <literal>aPerson.getEvents()</literal>. Usamos una colección Java, un <literal>Set</literal>, porque la colección no contendrá elementos duplicados y el ordenamiento no nos es relevante."
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr "Hasta ahora hemos diseñado asociaciones unidireccionales multivaluadas, implementadas con un <literal>Set</literal>. Escribamos el código para esto en las clases Java y luego lo mapeemos:"
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr "Antes que mapeemos esta asociación, piensa sobre el otro lado. Claramente, podemos mantener esto solamente unidireccional. O podemos crear otra colección en el <literal>Event</literal>, si queremos ser capaces de navegarlos bidireccionalmente; por ejemplo, <literal>anEvent.getParticipants()</literal>. Esta es una elección de diseño que recae en ti, pero lo que está claro de esta discusión es la multiplicidad de la asociación: \"multi\" valuada a ambos lados, llamamos a esto una asociación <emphasis>muchos-a-muchos</emphasis>. Por lo tanto, usamos un mapeo many-to-many de Hibernate:"
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr ""
+ "<![CDATA[<class name=\"Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr "Hibernate soporta todo tipo de mapeos de colección, siendo el más común un <literal><set></literal>. Para una asociación muchos-a-muchos (o relación de entidad <emphasis>n:m</emphasis>), se necesita una tabla de asociación. Cada fila en esta tabla representa un enlace entre una persona y un evento. Esta tabla se configura con el atributo <literal>table</literal> del elemento <literal>set</literal>. El nombre de la columna identificadora en la asociación, para el lado de la persona, se define con el elemento <literal><key></literal>. El nombre de columna para el lado del evento se define con el atributo <literal>column</literal> del <literal><many-to-many></literal>. También tienes que decirle a Hibernate la clase de los objetos en tu colección (correcto: la clase del otro lado de la colección de referencias)."
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr "El esquema de base de datos para este mapeo es, por lo tanto:"
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr "Trabajando la asociación"
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr "Traigamos alguna gente y eventos juntos en un nuevo método en <literal>EventManager</literal>:"
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ " Session session = HibernateUtil.currentSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " tx.commit();\n"
+ " HibernateUtil.closeSession();\n"
+ "}]]>"
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr "Después de cargar una <literal>Person</literal> y un <literal>Event</literal>, simplemente modifica la colección usando sus métodos normales. Como puedes ver, no hay una llamada explícita a <literal>update()</literal> o <literal>save()</literal>. Hibernate detecta automáticamente que la colección ha sido modificada y necesita ser salvada. Esto es llamado <emphasis>chequeo sucio automótico (automatic dirty checking)</emphasis>, y también puedes intentarlo modificando el nombre de la propiedad de fecha de cualquiera de tus objetos. Mientras estén en estado <emphasis>persistente</emphasis>, esto es, ligados a una <literal>Session</literal> de Hibernate particular (es decir, justo han sido cargados o almacenados en una unidad de trabajo), Hibernate monitoriza cualquier cambio y ejecuta SQL en estilo escribe-por-detrás. El proceso de sincronización del estado de memoria con la base de datos, usu!
almente sólo al final de una unidad de trabajo, es llamado <emphasis>limpieza (flushing)</emphasis>."
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr "Podrías, por supuesto, cargar persona y evento en unidades de trabajo diferentes. O modificas un objeto fuera de una <literal>Session</literal>, cuando no está en estado persistente (si antes era persistente llamamos a este estado <emphasis>separado (detached) </emphasis>). En código (no muy realista), esto se vería como sigue:"
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr ""
+ "<![CDATA[ private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.currentSession();\n"
+ " Transaction tx = session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " tx.commit();\n"
+ " HibernateUtil.closeSession();\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson is detached\n"
+ "\n"
+ " Session session2 = HibernateUtil.currentSession();\n"
+ " Transaction tx2 = session.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " tx2.commit();\n"
+ " HibernateUtil.closeSession();\n"
+ " }\n"
+ "]]>"
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr "La llamada a <literal>update</literal> hace a un objeto persistente de nuevo, podrías decir que la liga a una nueva unidad de trabajo, de modo que cualquier modificación que le hagas mientras esté separado puede ser salvada a base de datos."
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr "Bueno, esto no es muy usado en nuestra situación actual, pero es un concepto importante que puedes diseñar en tu propia aplicación. Por ahora, completa este ejercicio agregando una nueva acción al método main de <literal>EventManager</literal> y llámala desde la línea de comandos. Si necesitas los identificadores de una persona o evento, el método <literal>save()</literal> los devuelve."
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr "Esto fue un ejemplo de una asociación entre dos clases igualmente importantes, dos entidades. Como se ha mencionado anteriormente, hay otras clases y tipos en un modelo típico, usualmente \"menos importantes\". Algunos ya los habrás visto, como un <literal>int</literal> o un <literal>String</literal>. Llamamos a estas clases <emphasis>tipos de valor (value types)</emphasis>, y sus instancias <emphasis>dependen</emphasis> de una entidad en particular. Las instancias de estos tipos no tienen su propia identidad, ni son compartidas entre entidades (dos personas no referencian el mismo objeto <literal>firstname</literal>, incluso si tuvieran el mismo primer nombre). Por supuesto, los tipos de valor no sólo pueden encontrarse en el JDK (de hecho, en una aplicación Hibernate todas las clases del JDK son consideradas tipos de valor), sino que además puedes escribir por ti mismo clases dependientes, por ejemplo, <literal>Address</li!
teral> o <literal>MonetaryAmount</literal>."
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr "También puedes diseñar una colección de tipos de valor. Esto es conceptualmente muy diferente de una colección de referencias a otras entidades, pero se ve casi lo mismo en Java."
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr "Colección de valores"
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr "Agregamos una colección de objetos tipificados en valor a la entidad <literal>Person</literal>. Queremos almacenar direcciones de email, de modo que el tipo que usamos es <literal>String</literal>, y la colección es nuevamente un <literal>Set</literal>:"
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr "El mapeo de este <literal>Set</literal>:"
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr "La diferencia comparada con el mapeo anterior es la parte <literal>element</literal>, que le dice a Hibernate que la colección no contiene referencias a otra entidad, sino una colección de elementos de tipo <literal>String</literal> (el nombre en minúsculas te dice que es un tipo/conversor de mapeo de Hibernate). Una vez más, el atributo <literal>table</literal> del elemento <literal>set</literal> determina el nombre de la tabla para la colección. El elemento <literal>key</literal> define el nombre de la columna clave foránea en la tabla de colección. El atributo <literal>column</literal> en el elemento <literal>element</literal> define el nombre de columna donde realmente serán almacenados los valores <literal>String</literal>."
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr "Echa una mirada al esquema actualizado:"
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr "Puedes ver que la clave primaria de la tabla de colección es de hecho una clave compuesta, usando ambas columnas. Esto implica también que no pueden haber direcciones de email duplicadas por persona, que es exactamente la semántica que necesitamos para un conjunto en Java."
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr "Puedes ahora intentar y agregar elementos a esta colección, al igual que hicimos antes enlazando personas y eventos. Es el mismo código en Java."
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr "Asociaciones bidireccionales"
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr "A continuacion vamos a mapear una asociación bidireccional, haciendo que la asociación entre persona y evento funcione desde ambos lados en Java. Por supuesto, el esquema de base de datos no cambia; todavía necesitamos multiplicidad muchos-a-muchos. Una base de datos relacional es más flexible que un lenguaje de programación de red, así que no necesita nada parecido a una dirección de navegación; los datos pueden ser vistos y recuperados en cualquier forma posible."
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr "Primero agrega una colección de participantes a la clase de eventos <literal>Event</literal>:"
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr "Ahora mapea este lado de la asociación también, en <literal>Event.hbm.xml</literal>."
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"Person\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr "Como ves, estos son mapeos normales de <literal>set</literal> en ambos documentos de mapeo. Nota que los nombres de columnas en <literal>key</literal> y <literal>many-to-many</literal> fueron permutados en ambos documentos de mapeo. Aquí la adición más importante es el atributo <literal>inverse=\"true\"</literal> en el elemento <literal>set</literal> del mapeo de colección de <literal>Event</literal>."
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr "Lo que esto significa es que Hibernate debe tomar el otro lado - la clase <literal>Person</literal> - cuando necesite descubrir información sobre el enlace entre las dos. Esto será mucho más fácil de entender una vez que veas cómo se crea el enlace bidireccional entre nuestras dos entidades."
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr "Trabajando enlaces bidireccionales"
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr "Primero, ten en mente que Hhibernate no afecta la semántica normal de Java. ¿Cómo hemos creado un enlace entre una <literal>Person</literal> y un <literal>Event</literal> en el ejemplo unidireccional? Hemos agregado una instancia de <literal>Event</literal> a la colección de referencias de eventos de una instancia de <literal>Person</literal>. De modo que, obviamente, si queremos que este enlace funcione bidireccionalmente, tenemos que hacer lo mismo del otro lado, agregando una referencia a <literal>Person</literal> a la colección en un <literal>Event</literal>. Este \"establecer el enlace a ambos lados\" es absolutamente necesario y nunca debes olvidar hacerlo."
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr "Muchos desarrolladores programan a la defensiva y crean métodos de manejo de un enlace para establecer correctamente ambos lados, por ejemplo en <literal>Person</literal>:"
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr "Nota que los métodos get y set para esta colección son ahora protegidos. Esto le permite a clases en el mismo paquete y a subclases acceder aún a los métodos, pero previene a cualquier otro de ensuciarse con la colección directamente (bueno, casi). Probablemente debas hacer lo mismo con la colección al otro lado."
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr "Y ¿qué del atributo de mapeo <literal>inverse</literal>? Para ti, y para Java, un enlace bidireccional es simplemente cuestión de establecer correctamente las referencias a ambos lados. Hibernate, sin embargo, no tiene suficiente información para arreglar correctamente sentencias <literal>INSERT</literal> y <literal>UPDATE</literal> de SQL (para evitar violación de restricciones), y necesita alguna ayuda para manejar asociaciones bidireccionales apropiadamente. El hacer un lado de la asociación <literal>inverse</literal> le dice a Hibernate que basicamente lo ignore, que lo considere un <emphasis>espejo</emphasis> del otro lado. Esto es todo lo necesario para que Hibernate resuelva todas las incidencias al transformar un modelo de navegación direccional a un esquema SQL de base de datos. Las reglas que tienes que recordar son directas: Todas las asociaciones bidireccionales necesitan uno de los lados como <literal>inverse</!
literal>. En una asociación uno-a-muchos debe ser el lado-de-muchos. En una asociación muchos-a-muchos, puedes tomar cualquier lado, no hay diferencia."
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr "Summary"
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr "Este tutorial cubrió los fundamentos de escribir una simple aplicación independiente de Hibernate."
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr "Si ya te sientes confidente con Hibernate, continúa navegando a través de la tabla de contenidos de la documentación de referencia para los temas que encuentres interesantes. Los más consultados son procesamiento transaccional (<xref linkend=\"transactions\"/>), rendimiento de recuperación (<xref linkend=\"performance\"/>), o el uso de la API (<xref linkend=\"objectstate\"/>) y las funcionalidades de consulta (<xref linkend=\"objectstate-querying\"/>)."
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr "No olvides chequear el sitio web de Hibernate por más (especializados) tutoriales."
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr ""
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr ""
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr ""
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr ""
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr ""
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr ""
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr ""
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr ""
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr ""
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr ""
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr ""
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr ""
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr ""
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr ""
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr ""
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr ""
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr ""
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr ""
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr ""
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr ""
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr ""
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr ""
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr ""
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr ""
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr ""
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr ""
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr ""
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,420 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr "Mapeo XML"
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr "Nota que esta es una funcionalidad experimental en Hibernate 3.0 y está bajo un desarrollo extremadamente activo."
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr "Trabajando con datos XML"
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr "Hibernate te permite trabajar con datos XML persistentes en casi la misma forma que trabajas con POJOs persistentes. Un árbol XML analizado (parsed) puede ser pensado como sólo otra forma de representar los datos relacionales a nivel de objetos, en vez de POJOs."
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr "Hibernate soporta dom4j como API para manipular árboles XML. Puedes escribir consultas que traigan árboles dom4j de la base de datos y tener cualquier modificación que hagas al árbol sincronizada automáticamente a la base de datos. Puedes incluso tomar un documento XML, analizarlo usando dom4j, y escribirlo a la base de datos con cualquiera de las operaciones básicas de Hibernate: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (la fusión no está aún soportada)."
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr "Esta funcionalidad tiene muchas aplicaciones incluyendo la importación/exportación de datos, externalización de datos de entidad vÃa JMS o SOAP y reportes basados en XSLT."
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr "Un solo mapeo puede ser usado para mapear simultáneamente las propiedades de una clase y los nodos de un documento XML a la base de datos, o, si no hay ninguna clase a mapear, puede ser usado para mapear sólo el XML."
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr "Especificando los mapeos de XML y de clase juntos"
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr "He aquà un ejemplo de mapear un POJO y XML simultáneamente:"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr "Especificando sólo un mapeo XML"
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr "He aquà un ejemplo donde no hay ninguna clase POJO:"
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr "Este mapeo te permite acceder a los datos como un árbol dom4j, o como un grafo de pares nombre/valor de propiedad (<literal>Map</literal>s de Java). Los nombres de propiedades son construcciones puramente lógicas a las que se puede hacer referencia en consultas HQL."
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr "Mapeo de metadatos XML"
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr "Muchos elementos de mapeo de Hibernate aceptan el atributo <literal>node</literal>. Esto te permite espcificar el nombre de un atributo o elemento XML que contenga los datos de la propiedad o entidad. El formato del atributo <literal>node</literal> debe ser uno de los siguientes:"
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr "<literal>\"element-name\"</literal> - mapea al elemento XML mencionado"
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr "<literal>\"@attribute-name\"</literal> - mapea al atributo XML mencionado"
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr "<literal>\".\"</literal> - mapea al elemento padre"
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr "<literal>\"element-name/@attribute-name\"</literal> - mapea al atributo mencionado del elemento mencionado"
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr "Para las colecciones y asociaciones monovaluadas, existe un atributo adicional <literal>embed-xml</literal>. Si <literal>embed-xml=\"true\"</literal>, que es el valor por defecto, el árbol XML para la entidad asociada (o colección de tipo de valor) será embebida directamente en el árbol XML para la entidad que posee la asociación. En otro caso, si <literal>embed-xml=\"false\"</literal>, sólo el valor identificador referenciado aparecerá en el XML para asociaciones de punto único y para las colecciones simplemente no aparecerá en absoluto."
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr "¡Debes ser cuidadoso de no dejar <literal>embed-xml=\"true\"</literal> para demasiadas asociaciones, ya que XML no trata bien la circularidad!"
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr "en este caso, hemos decidido embeber la colección de ids de cuenta, pero no los datos reales de cuenta. La siguiente consulta HQL:"
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr "devolverÃa conjuntos de datos como estos:"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr "Si estableces <literal>embed-xml=\"true\"</literal> en el mapeo <literal><one-to-many></literal>, los datos podrÃan verse asÃ:"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr "Manipulando datos XML"
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr "Vamos a releer y actualizar documentos XML en la aplicación. Hacemos esto obteniendo una sesión dom4j:"
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr "Es extremadamente útil combinar esta funcionalidad con la operación <literal>replicate()</literal> de Hibernate para implementar la importación/exportación de datos basada en XML."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/es-ES/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/es-ES/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/es-ES/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - Persistance relationnelle en Java standard"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "Documentation de référence d'Hibernate"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr "Architecture"
+
+#: index.docbook:24
+msgid "Overview"
+msgstr "Généralités"
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr "Voici une vue (très) haut niveau de l'architecture d'Hibernate :"
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr "Ce diagramme montre Hibernate utilisant une base de données et des données de configuration pour fournir un service de persistance (et des objets persistants) à l'application."
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 "Nous aimerions décrire une vue plus détaillée de l'architecture. Malheureusement, Hibernate est flexible et supporte différentes approches. Nous allons en montrer les deux extrêmes. L'architecture légère laisse l'application fournir ses propres connexions JDBC et gérer ses propres transactions. Cette approche utilise le minimum des APIs Hibernate :"
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr "L'architecture la plus complète abstrait l'application des APIs JDBC/JTA sous-jacentes et laisse Hibernate s'occuper des détails."
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr "Voici quelques définitions des objets des diagrammes :"
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr "Un cache threadsafe (immuable) des mappings vers une (et une seule) base de données. Une factory (fabrique) de <literal>Session</literal> et un client de <literal>ConnectionProvider</literal>. Peut contenir un cache optionnel de données (de second niveau) qui est réutilisable entre les différentes transactions que cela soit au sein du même processus (JVLM) ou par plusieurs nœuds d'un cluster."
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr "Session (<literal>org.hibernate.Session</literal>)"
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr "Un objet mono-threadé, à durée de vie courte, qui représente une conversation entre l'application et l'entrepôt de persistance. Encapsule une connexion JDBC. Factory (fabrique) des objets <literal>Transaction</literal>. Contient un cache (de premier niveau) des objets persistants, ce cache est obligatoire. Il est utilisé lors de la navigation dans le graphe d'objets ou lors de la récupération d'objets par leur identifiant."
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr "Objets et Collections persistants"
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr "Objets mono-threadés à vie courte contenant l'état de persistance et la fonction métier. Ceux-ci sont en général les objets de type JavaBean (ou POJOs) ; la seule particularité est qu'ils sont associés avec une (et une seule) <literal>Session</literal>. Dès que la <literal>Session</literal> est fermée, ils seront détachés et libres d'être utilisés par n'importe laquelle des couches de l'application (ie. de et vers la présentation en tant que Data Transfer Objects - DTO : objet de transfert de données)."
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr "Objets et collections transients"
+
+#: index.docbook:119
+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 "Instances de classes persistantes qui ne sont actuellement pas associées à une <literal>Session</literal>. Elles ont pu être instanciées par l'application et ne pas avoir (encore) été persistées ou elle ont pu être instanciées par une <literal>Session</literal> fermée."
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr "Transaction (<literal>org.hibernate.Transaction</literal>)"
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 "(Optionnel) Un objet mono-threadé à vie courte utilisé par l'application pour définir une unité de travail atomique. Abstrait l'application des transactions sous-jacentes qu'elles soient JDBC, JTA ou CORBA. Une <literal>Session</literal> peut fournir plusieurs <literal>Transaction</literal>s dans certains cas. Toutefois, la délimitation des transactions, via l'API d'Hibernate ou par la <literal>Transaction</literal> sous-jacente, n'est jamais optionnelle!"
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr "(Optionnel) Une fabrique de (pool de) connexions JDBC. Abstrait l'application de la <literal>Datasource</literal> ou du <literal>DriverManager</literal> sous-jacent. Non exposé à l'application, mais peut être étendu/implémenté par le développeur."
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr "(Optionnel) Une fabrique d'instances de <literal>Transaction</literal>. Non exposé à l'application, mais peut être étendu/implémenté par le développeur."
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr "Interfaces d'extension"
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "Hibernate fournit de nombreuses interfaces d'extensions optionnelles que vous pouvez implémenter pour personnaliser le comportement de votre couche de persistance. Reportez vous à la documentation de l'API pour plus de détails."
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr "Dans une architecture légère, l'application n'aura pas à utiliser les APIs <literal>Transaction</literal>/<literal>TransactionFactory</literal> et/ou n'utilisera pas les APIs <literal>ConnectionProvider</literal> pour utiliser JTA ou JDBC."
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr "Etats des instances"
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr "Une instance d'une classe persistante peut être dans l'un des trois états suivants, définis par rapport à un <emphasis>contexte de persistance</emphasis>. L'objet <literal>Session</literal> d'hibernate correspond à ce concept de contexte de persistance :"
+
+#: index.docbook:188
+msgid "transient"
+msgstr "passager (transient)"
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr "L'instance n'est pas et n'a jamais été associée à un contexte de persistance. Elle ne possède pas d'identité persistante (valeur de clé primaire)"
+
+#: index.docbook:198
+msgid "persistent"
+msgstr "persistant"
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr "L'instance est associée au contexte de persistance. Elle possède une identité persistante (valeur de clé primaire) et, peut-être, un enregistrement correspondant dans la base. Pour un contexte de persistance particulier, Hibernate <emphasis>garantit</emphasis> que l'identité persistante est équivalente à l'identité Java (emplacement mémoire de l'objet)"
+
+#: index.docbook:212
+msgid "detached"
+msgstr "détaché"
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr "L'instance a été associée au contexte de persistance mais ce contexte a été fermé, ou l'instance a été sérialisée vers un autre processus. Elle possède une identité persistante et peut-être un enregistrement correspondant dans la base. Pour des instances détachées, Hibernate ne donne aucune garantie sur la relation entre l'identité persistante et l'identité Java."
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr "Intégration JMX"
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX est le standard J2EE de gestion des composants Java. Hibernate peut être géré via un service JMX standard. Nous fournissons une implémentation d'un MBean dans la distribution : <literal>org.hibernate.jmx.HibernateService</literal>."
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr "Pour avoir un exemple sur la manière de déployer Hibernate en tant que service JMX dans le serveur d'application JBoss Application Server, référez vous au guide utilisateur JBoss (JBoss User Guide). Si vous déployez Hibernate via JMX sur JBoss AS, vous aurez également les bénéfices suivants :"
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>Gestion de la session :</emphasis> Le cycle de vie de la <literal>Session</literal> Hibernate peut être automatiquement limitée à la portée d'une transaction JTA. Cela signifie que vous n'avez plus besoin d'ouvrir et de fermer la <literal>Session</literal> manuellement, cela devient le travail de l'intercepteur EJB de JBoss. Vous n'avez pas non plus à vous occuper des démarcations des transactions dans votre code (sauf si vous voulez écrire une couche de persistance qui soit portable, dans ce cas vous pouvez utiliser l'API optionnelle <literal>Transaction</literal> d'Hibernate). Vous appelez l'<literal>HibernateContext</literal> pour accéder à la <literal>Session</literal>."
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>Déploiement HAR :</emphasis> Habituellement vous déployez le service JMX Hibernate en utilisant le descripteur de déploiement de JBoss (dans un fichier EAR et/ou un SAR), il supporte toutes les options de configuration usuelles d'une <literal>SessionFactory</literal> Hibernate. Cependant, vous devez toujours nommer tous vos fichiers de mapping dans le descripteur de déploiement. Si vous décidez d'utiliser le déploiement optionnel sous forme de HAR, JBoss détectera automatiquement tous vos fichiers de mapping dans votre fichier HAR."
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr "Consultez le guide d'utilisation de JBoss AS pour plus d'informations sur ces options."
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr "Les statistiques pendant l'exécution d'Hibernate (au runtime) sont une autre fonctionnalité disponible en tant que service JMX. Voyez pour cela <xref linkend=\"configuration-optional-statistics\"/>."
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr "Support JCA"
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr "Hibernate peut aussi être configuré en tant que connecteur JCA. Référez-vous au site web pour de plus amples détails. Il est important de noter que le support JCA d'Hibernate est encore considéré comme expérimental."
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr "Sessions Contextuelles"
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 "Certaines applications utilisant Hibernate ont besoin d'une sorte de session \"contextuelle\", où une session est liée à la portée d'un contexte particulier. Cependant, les applications ne définissent pas toutes la notion de contexte de la même manière, et différents contextes définissent différentes portées à la notion de \"courant\". Les applications à base d'Hibernate, versions précédentes à la 3.0 utilisaient généralement un principe maison de sessions contextuelles basées sur le <literal>ThreadLocal</literal>, ainsi que sur des classes utilitaires comme <literal>HibernateUtil</literal>, ou utilisaient des framework tiers (comme Spring ou Pico) qui fournissaient des sessions contextuelles basées sur l'utilisation de proxy/interception."
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr "A partir de la version 3.0.1, Hibernate a ajouté la méthode <literal>SessionFactory.getCurrentSession()</literal>. Initialement, cela demandait l'usage de transactions <literal>JTA</literal>, où la transaction <literal>JTA</literal> définissait la portée et le contexte de la session courante. L'équipe Hibernate pense que, étant donnée la maturité des implémentations de <literal>JTA TransactionManager</literal> , la plupart (sinon toutes) des applications devraient utiliser la gestion des transactions par <literal>JTA</literal> qu'elles soient ou non déployées dans un conteneur <literal>J2EE</literal>. Par conséquent, vous devriez toujours contextualiser vos sessions, si vous en avez besoin, via la méthode basée sur JTA."
+
+#: index.docbook:307
+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 "Cependant, depuis la version 3.1, la logique derrière <literal>SessionFactory.getCurrentSession()</literal> est désormais branchable. A cette fin, une nouvelle interface d'extension (<literal>org.hibernate.context.CurrentSessionContext</literal>) et un nouveau paramètre de configuration (<literal>hibernate.current_session_context_class</literal>) ont été ajoutés pour permettre de configurer d'autres moyens de définir la portée et le contexte des sessions courantes."
+
+#: index.docbook:314
+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 "Allez voir les Javadocs de l'interface <literal>org.hibernate.context.CurrentSessionContext</literal> pour une description détaillée de son contrat. Elle définit une seule méthode, <literal>currentSession()</literal>, depuis laquelle l'implémentation est responsable de traquer la session courante du contexte. Hibernate fournit deux implémentation de cette interface."
+
+#: index.docbook:324
+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> - les sessions courantes sont associées à une transaction <literal>JTA</literal>. La logique est la même que l'ancienne approche basée sur JTA. Voir les javadocs pour les détails."
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - les sessions courantes sont associées au thread d'exécution. Voir les javadocs pour les détails."
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr "Les deux implémentations fournissent un modèle de programmation de type \"une session - une transaction à la base de données\", aussi connu sous le nom de <emphasis>session-per-request</emphasis>. Le début et la fin d'une session Hibernate sont définis par la durée d'une transaction de base de données. Si vous utilisez une démarcation programmatique de la transaction (par exemple sous J2SE ou JTA/UserTransaction/BMT), nous vous conseillons d'utiliser l'API Hibernate <literal>Transaction</literal> pour masquer le système de transaction utilisé. Si vous exécutez sous un conteneur EJB qui supporte CMT, vous n'avez besoin d'aucune opérations de démarcations de session ou transaction dans votre code puisque tout est géré de manière déclarative. Référez vous à <xref linkend=\"transactions\"/> pour plus d'informations et des exemples de code."
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr "Le paramètre de configuration <literal>hibernate.current_session_context_class</literal> définit quelle implémentation de <literal>org.hibernate.context.CurrentSessionContext</literal> doit être utilisée. Notez que pour assurer la compatibilité avec les versions précédentes, si ce paramètre n'est pas défini mais qu'un <literal>org.hibernate.transaction.TransactionManagerLookup</literal> est configuré, Hibernate utilisera le <literal>org.hibernate.context.JTASessionContext</literal>. La valeur de ce paramètre devrait juste nommer la classe d'implémentation à utiliser, pour les deux implémentations fournies, il y a cependant deux alias correspondant: \"jta\" et \"thread\"."
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,970 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr "Mapper les associations"
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr "Introduction"
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr "Correctement mapper les associations est souvent la tâche la plus difficile. Dans cette section nous traiterons les cas classiques les uns après les autres. Nous commencerons d'abbord par les mappings unidirectionnels, puis nous aborderons la question des mappings bidirectionnels. Nous illustrerons tous nos exemples avec les classes <literal>Person</literal> et <literal>Address</literal>."
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr "Nous utiliserons deux critères pour classer les associations : le premier sera de savoir si l'association est bâti sur une table supplémentaire d'association et le deuxieme sera basé sur la multiplicité de cette association."
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr "Autoriser une clé étrangère nulle est considéré comme un mauvais choix dans la construction d'un modèle de données. Nous supposerons donc que dans tous les exemples qui vont suivre on aura interdit la valeur nulle pour les clés étrangères. Attention, ceci ne veut pas dire que Hibernate ne supporte pas les clés étrangères pouvant prendre des valeurs nulles, les exemples qui suivent continueront de fonctionner si vous décidiez ne plus imposer la contrainte de non-nullité sur les clés étrangères."
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr "Association unidirectionnelle"
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr "plusieurs à un"
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr "Une <emphasis>association plusieurs-Ã -un (many-to-one) unidirectionnelle </emphasis> est le type que l'on rencontre le plus souvent dans les associations unidirectionnelles."
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr "un à un"
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr "une <emphasis>association un-à -un (one-to-one) sur une clé étrangère</emphasis> est presque identique. La seule différence est sur la contrainte d'unicité que l'on impose à cette colonne."
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr "Une <emphasis>association un-à -un (one-to-one) unidirectionnelle sur une clé primaire</emphasis> utilise un générateur d'identifiant particulier. (Remarquez que nous avons inversé le sens de cette association dans cet exemple.)"
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr "un à plusieurs"
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr "Une <emphasis>association un-à -plusieurs (one-to-many) unidirectionnelle sur une clé étrangère</emphasis> est vraiment inhabituelle, et n'est pas vraiment recommandée."
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr "Nous pensons qu'il est préférable d'utiliser une table de jointure pour ce type d'association."
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr "Associations unidirectionnelles avec tables de jointure"
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr "Une <emphasis>association unidirectionnelle un-à -plusieurs (one-to-many) avec une table de jointure</emphasis> est un bien meilleur choix. Remarquez qu'en spécifiant <literal>unique=\"true\"</literal>, on a changé la multiplicité plusieurs-à -plusieurs (many-to-many) pour un-à -plusieurs (one-to-many)."
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr "Une <emphasis>assiociation plusieurs-à -un (many-to-one) unidirectionnelle sur une table de jointure</emphasis> est très fréquente quand l'association est optionnelle."
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "Une <emphasis>association unidirectionnelle un-à -un (one-to-one) sur une table de jointure</emphasis> est extrèmement rare mais envisageable."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr "plusieurs à plusieurs"
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr "Finallement, nous avons <emphasis>l'association unidirectionnelle plusieurs-Ã -plusieurs (many-to-many)</emphasis>."
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr "Associations bidirectionnelles"
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr "un à plusieurs / plusieurs à un"
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr "Une <emphasis>association bidirectionnelle plusieurs à un (many-to-one)</emphasis> est le type d'association que l'on rencontre le plus souvent. (c'est la façon standard de créer des relations parents/enfants.)"
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr "Si vous utilisez une <literal>List</literal> (ou toute autre collection indexée) vous devez paramétrer la colonne <literal>key</literal> de la clé étrangère à <literal>not null</literal>, et laisser Hibernate gérer l'association depuis l'extrémité collection pour maintenir l'index de chaque élément (rendant l'autre extrémité virtuellement inverse en paramétrant <literal>update=\"false\"</literal> et <literal>insert=\"false\"</literal>):"
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr "Un à un"
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr "un à plusieurs / plusieurs à un"
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr "Un à un"
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr "Des associations encore plus complexes sont <emphasis>extrêmement</emphasis> rares. Hibernate permet de gérer des situations plus complexes en utilisant des parties SQL dans les fichiers de mapping. Par exemple, si une table avec l'historiques des informations d'un compte définit les colonnes <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> et <literal>effectiveStartDate</literal>, mappées de telle sorte:"
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr "alors nous pouvons mapper une association à l'instance <emphasis>courante</emphasis> (celle avec une <literal>effectiveEndDate</literal>) nulle en utilisant:"
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr "Dans un exemple plus complexe, imaginez qu'une association entre <literal>Employee</literal> et <literal>Organization</literal> est gérée dans une table <literal>Employment</literal> pleines de données historiques. Dans ce cas, une association vers l'employeur <emphasis>le plus récent</emphasis> (celui avec la <literal>startDate</literal> la plus récente) pourrait être mappée comme cela:"
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr "Vous pouvez être créatif grace à ces possibilités, mais il est généralement plus pratique d'utiliser des requêtes HQL ou criteria dans ce genre de situation."
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,3057 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr "Mapping O/R basique"
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr "Déclaration de Mapping"
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr "Les mappings Objet/relationnel sont généralement définis dans un document XML. Le document de mapping est conçu pour être lisible et éditable à la main. Le langage de mapping est Java-centrique, c'est à dire que les mappings sont construits à partir des déclarations des classes persistantes et non des déclarations des tables."
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr "Remarquez que même si beaucoup d'utilisateurs de Hibernate préfèrent écrire les fichiers de mappings à la main, plusieurs outils existent pour générer ce document, notamment XDoclet, Middlegen et AndroMDA."
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr "Démarrons avec un exemple de mapping :"
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" \n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\" \n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\" \n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr "Etudions le contenu du document de mapping. Nous décrirons uniquement les éléments et attributs du document utilisés par Hibernate à l'exécution. Le document de mapping contient aussi des attributs et éléments optionnels qui agissent sur le schéma de base de données exporté par l'outil de génération de schéma. (Par exemple l'attribut <literal>not-null</literal>.)"
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr "Doctype"
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr "Tous les mappings XML devraient utiliser le doctype indiqué. Ce fichier est présent à l'URL ci-dessus, dans le répertoire <literal>hibernate-x.x.x/src/org/hibernate</literal> ou dans <literal>hibernate3.jar</literal>. Hibernate va toujours chercher la DTD dans son classpath en premier lieu. Si vous constatez des recherches de la DTD sur Internet, vérifiez votre déclaration de DTD par rapport au contenu de votre classpath."
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr "hibernate-mapping"
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr "Cet élément a plusieurs attributs optionnels. Les attributs <literal>schema</literal> et <literal>catalog</literal> indiquent que les tables référencées par ce mapping appartiennent au schéma nommé et/ou au catalogue. S'ils sont spécifiés, les noms de tables seront qualifiés par les noms de schéma et catalogue. L'attribut <literal>default-cascade</literal> indique quel type de cascade sera utlisé par défaut pour les propriétés et collections qui ne précisent pas l'attribut <literal>cascade</literal>. L'attribut <literal>auto-import</literal> nous permet d'utiliser par défaut des noms de classes non qualifiés dans le langage de requête."
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "<literal>schema</literal> (optionnel) : Le nom d'un schéma de base de données."
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr "<literal>catalog</literal> (optionnel) : Le nom d'un catalogue de base de données."
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr "<literal>default-cascade</literal> (optionnel - par défaut vaut : <literal>none</literal>) : Un type de cascade par défaut."
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr "<literal>default-access</literal> (optionnel - par défaut vaut : <literal>property</literal>) : Comment hibernate accèdera aux propriétés. On peut aussi redéfinir sa propre implémentation de <literal>PropertyAccessor</literal>."
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr "<literal>default-lazy</literal> (optionnel - par défaut vaut : <literal>true</literal>) : Valeur par défaut pour un attribut <literal>lazy</literal> non spécifié : celui des mappings de classes et de collection."
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr "<literal>auto-import</literal> (optionnel - par défaut vaut : <literal>true</literal>) : Spécifie si l'on peut utiliser des noms de classes non qualifiés (des classes de ce mapping) dans le langage de requête."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr "<literal>package</literal> (optionnel) : Préfixe de package par défaut pour les noms de classe non qualifiés du document de mapping."
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr "Si deux classes possèdent le même nom de classe (non qualifié), vous devez indiquer <literal>auto-import=\"false\"</literal>. Hibernate lancera une exception si vous essayez d'assigner à deux classes le même nom importé."
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr "Notez que l'élément <literal>hibernate-mapping</literal> vous permet d'imbriquer plusieurs mappings de <literal><class></literal> persistantes, comme dans l'exemple ci-dessus. Cependant la bonne pratique (ce qui est attendu par certains outils) est de mapper une seule classe (ou une seule hiérarchie de classes) par fichier de mapping et de nommer ce fichier d'après le nom de la superclasse, par exemple <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, ou en cas d'héritage, <literal>Animal.hbm.xml</literal>."
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr "<title>class</title>"
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "Déclarez une classe persistante avec l'élément <literal>class</literal> :"
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " catalog=\"catalog\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ "/>]]>"
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr "<literal>name</literal> (optionnel) : Le nom Java complet de la classe (ou interface) persistante. Si cet attribut est absent, il est supposé que ce mapping ne se rapporte pas à une entité POJO."
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr "<literal>table</literal> (optionnel - par défaut le nom (non-qualifié) de la classe) : Le nom de sa table en base de données."
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr "<literal>discriminator-value</literal> (optionnel - par défaut le nom de la classe) : Une valeur permettant de distinguer les sous-classes dans le cas de l'utilisation du polymorphisme. Les valeurs <literal>null</literal> et <literal>not null</literal> sont autorisées."
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "<literal>mutable</literal> (optionnel, vaut <literal>true</literal> par défaut) : Spécifie que des instances de la classe sont (ou non) immuables."
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr "<literal>schema</literal> (optionnel) : Surcharge le nom de schéma spécifié par l'élément racine <literal><hibernate-mapping></literal>."
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr "<literal>catalog</literal> (optionnel) : Surcharge le nom du catalogue spécifié par l'élément racine <literal><hibernate-mapping></literal>."
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr "<literal>proxy</literal> (optionnel) : Spécifie une interface à utiliser pour l'initialisation différée (lazy loading) des proxies. Vous pouvez indiquer le nom de la classe elle-même."
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>dynamic-update</literal> (optionnel, par défaut à <literal>false</literal>) : Spécifie que les <literal>UPDATE</literal> SQL doivent être générés à l'exécution et contenir uniquement les colonnes dont les valeurs ont été modifiées."
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr "<literal>dynamic-insert</literal> (optionnel, par défaut à <literal>false</literal>): Spécifie que les <literal>INSERT</literal> SQL doivent être générés à l'exécution et ne contenir que les colonnes dont les valeurs sont non nulles."
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>select-before-update</literal> (optionnel, par défaut à <literal>false</literal>): Spécifie que Hibernate ne doit <emphasis>jamais</emphasis> exécuter un <literal>UPDATE</literal> SQL sans être certain qu'un objet a été réellement modifié. Dans certains cas, (en réalité, seulement quand un objet transient a été associé à une nouvelle session par <literal>update()</literal>), cela signifie que Hibernate exécutera un <literal>SELECT</literal> SQL pour s'assurer qu'un <literal>UPDATE</literal> SQL est véritablement nécessaire."
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr "<literal>polymorphism</literal> (optionnel, vaut <literal>implicit</literal> par défaut) : Détermine si, pour cette classe, une requête polymorphique implicite ou explicite est utilisée."
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>where</literal> (optionnel) spécifie une clause SQL <literal>WHERE</literal> à utiliser lorsque l'on récupère des objets de cette classe."
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>persister</literal> (optionnel) : Spécifie un <literal>ClassPersister</literal> particulier."
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr "<literal>batch-size</literal> (optionnel, par défaut = <literal>1</literal>) : spécifie une taille de batch pour remplir les instances de cette classe par identifiant en une seule requête."
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr "<literal>optimistic-lock</literal> (optionnel, par défaut = <literal>version</literal>) : Détermine la stratégie de verrou optimiste."
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>lazy</literal> (optionnel) : Déclarer <literal>lazy=\"true\"</literal> est un raccourci pour spécifier le nom de la classe comme étant l'interface <literal>proxy</literal>."
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>entity-name</literal> (optionnel) : Hibernate3 permet à une classe d'être mappée plusieurs fois (potentiellement à plusieurs tables), et permet aux mappings d'entité d'être représentés par des Maps ou du XML au niveau Java. Dans ces cas, vous devez indiquer un nom explicite arbitraire pour les entités. Voir <xref linkend=\"persistent-classes-dynamicmodels\"/> et <xref linkend=\"xml\"/> pour plus d'informations."
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr "<literal>catalog</literal> (optionnel) : The name of a database catalog used for this class and its table."
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr "<literal>check</literal> (optionnel) : expression SQL utilisée pour générer une contrainte de vérification multi-lignes pour la génération automatique de schéma."
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>rowid</literal> (optionnel) : Hibernate peut utiliser des ROWID sur les bases de données qui utilisent ce mécanisme. Par exemple avec Oracle, Hibernate peut utiliser la colonne additionnelle <literal>rowid</literal> pour des mises à jour rapides si cette option vaut <literal>rowid</literal>. Un ROWID représente la localisation physique d'un tuple enregistré."
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>subselect</literal> (optionnel) : Permet de mapper une entité immuable en lecture-seule sur un sous-select de base de données. Utile pour avoir une vue au lieu d'une table en base, mais à éviter. Voir plus bas pour plus d'information."
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr "<literal>abstract</literal> (optionnel) : Utilisé pour marquer des superclasses abstraites dans des hiérarchies de <literal><union-subclass></literal>."
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "Il est tout à fait possible d'utiliser une interface comme nom de classe persistante. Vous devez alors déclarer les classes implémentant cette interface en utilisant l'élément <literal><subclass></literal>. Vous pouvez faire persister toute classe interne <emphasis>static</emphasis>. Vous devez alors spécifier le nom de la classe par la notation habituelle des classes internes c'est à dire <literal>eg.Foo$Bar</literal>."
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr "Les classes immuables, <literal>mutable=\"false\"</literal>, ne peuvent pas être modifiées ou supprimées par l'application. Cela permet à Hibernate de faire quelques optimisations mineures sur les performances."
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "L'attribut optionnnel <literal>proxy</literal> permet les intialisations différées des instances persistantes de la classe. Hibernate retournera initialement des proxies CGLIB qui implémentent l'interface nommée. Le véritable objet persistant ne sera chargé que lorsque une méthode du proxy sera appelée. Voir plus bas le paragraphe abordant les proxies et le chargement différé (lazy initialization)."
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "Le polymorphisme <emphasis>implicite</emphasis> signifie que les instances de la classe seront retournées par une requête qui utilise les noms de la classe ou de chacune de ses superclasses ou encore des interfaces implémentées par cette classe ou ses superclasses. Les instances des classes filles seront retournées par une requête qui utilise le nom de la classe elle même. Le polymorphisme <emphasis>explicite</emphasis> signifie que les instances de la classe ne seront retournées que par une requête qui utilise explicitement son nom et que seules les instances des classes filles déclarées dans les éléments <literal><subclass></literal> ou <literal><joined-subclass></literal> seront retournées. Dans la majorités des cas la valeur par défaut, <literal>polymorphism=\"implicit\"</literal>, est appropriée. Le polymorphisme explicite est utile lorsque deux classes différentes sont mappées à la même table (ceci permet d'écrire une classe \!
"légère\" qui ne contient qu'une partie des colonnes de la table - voir la partie design pattern du site communautaire)."
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr "L'attribut <literal>persister</literal> vous permet de customiser la stratégie utilisée pour la classe. Vous pouvez, par exemple, spécifier votre propre sous-classe de <literal>org.hibernate.persister.EntityPersister</literal> ou vous pourriez aussi créer une nouvelle implémentation de l'interface <literal>org.hibernate.persister.ClassPersister</literal> qui proposerait une persistance via, par exemple, des appels de procédures stockées, de la sérialisation vers des fichiers plats ou un annuaire LDAP. Voir <literal>org.hibernate.test.CustomPersister</literal> pour un exemple simple (d'une \"persistance\" vers une <literal>Hashtable</literal>)."
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr "Notez que les paramètres <literal>dynamic-update</literal> et <literal>dynamic-insert</literal> ne sont pas hérités par les sous-classes et peuvent donc être spécifiés pour les éléments <literal><subclass></literal> ou <literal><joined-subclass></literal> Ces paramètres peuvent améliorer les performances dans certains cas, mais peuvent aussi les amoindrir. A utiliser en connaissance de causes."
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr "L'utilisation de <literal>select-before-update</literal> va généralement faire baisser les performances. Ce paramètre est pratique pour prévenir l'appel inutile d'un trigger sur modification quand on réattache un graphe d'instances à une <literal>Session</literal>."
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "Si vous utilisez le <literal>dynamic-update</literal>, les différentes stratégies de verrouillage optimiste (optimistic locking) sont les suivantes:"
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "<literal>version</literal> vérifie les colonnes version/timestamp"
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr "<literal>all</literal> vérifie toutes les colonnes"
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr "<literal>dirty</literal> vérifie les colonnes modifiées, permettant des updates concurrents"
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr "<literal>none</literal> pas de verrouillage optimiste"
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "Nous encourageons <emphasis>très</emphasis> fortement l'utilisation de colonnes de version/timestamp pour le verrouillage optimiste avec Hibernate. C'est la meilleure stratégie en regard des performances et la seule qui gère correctement les modifications sur les objets détachés (c'est à dire lorsqu'on utilise <literal>Session.merge()</literal>)."
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr "Il n'y a pas de différence entre table et vue pour le mapping Hibernate, tant que c'est transparent au niveau base de données (remarquez que certaines BDD ne supportent pas les vues correctement, notamment pour les updates). Vous rencontrerez peut-être des cas où vous souhaitez utiliser une vue mais ne pouvez pas en créer sur votre BDD (par exemple à cause de schémas anciens et figés). Dans ces cas, vous pouvez mapper une entité immuable en lecture seule sur un sous-select SQL donné:"
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr "Déclarez les tables à synchroniser avec cette entité pour assurer que le flush automatique se produise correctement, et pour que les requêtes sur l'entité dérivée ne renvoient pas des données périmées. Le litéral <literal><subselect></literal> est disponible comme attribut ou comme élément de mapping."
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr "<title>id</title>"
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr "Les classes mappées <emphasis>doivent</emphasis> déclarer la clef primaire de la table en base de données. La plupart des classes auront aussi une propriété de type javabean présentant l'identifiant unique d'une instance. L'élément <literal><id></literal> sert à définir le mapping entre cette propriété et la clef primaire en base."
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "<literal>name</literal> (optionnel) : Nom de la propriété qui sert d'identifiant."
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr "<literal>type</literal> (optionnel) : Nom indiquant le type Hibernate."
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr "<literal>column</literal> (optionnel - le nom de la propriété est pris par défaut) : Nom de la clef primaire."
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr "<literal>unsaved-value</literal> (optionnel - par défaut une valeur \"bien choisie\") : Une valeur de la propriété d'identifiant qui indique que l'instance est nouvellement instanciée (non sauvegardée), et qui la distingue des instances <literal>transient</literal>s qui ont été sauvegardées ou chargées dans une session précédente."
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr "<literal>access</literal> (optionnel - par défaut <literal>property</literal>) : La stratégie que doit utiliser Hibernate pour accéder aux valeurs des propriétés."
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr "Si l'attribut <literal>name</literal> est absent, Hibernate considère que la classe ne possède pas de propriété identifiant."
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr "L'attribut <literal>unsaved-value</literal> est important ! Si l'identifiant de votre classe n'a pas une valeur par défaut compatible avec le comportement standard de Java (zéro ou null), vous devez alors préciser la valeur par défaut."
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr "La déclaration alternative <literal><composite-id></literal> permet l'acccès aux données d'anciens systèmes qui utilisent des clefs composées. Son utilisation est fortement déconseillée pour d'autres cas."
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr "Generator"
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr "L'élément fils <literal><generator></literal> nomme une classe Java utilisée pour générer les identifiants uniques pour les instances des classes persistantes. Si des paramètres sont requis pour configurer ou initialiser l'instance du générateur, ils sont passés en utilisant l'élément <literal><param></literal>."
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr "Tous les générateurs doivent implémenter l'interface <literal>org.hibernate.id.IdentifierGenerator</literal>. C'est une interface très simple ; certaines applications peuvent proposer leur propre implémentations spécialisées. Cependant, Hibernate propose une série d'implémentations intégrées. Il existe des noms raccourcis pour les générateurs intégrés :"
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr "increment"
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr "Génère des identifiants de type <literal>long</literal>, <literal>short</literal> ou <literal>int</literal> qui ne sont uniques que si aucun autre processus n'insère de données dans la même table. <emphasis>Ne pas utiliser en environnement clusterisé.</emphasis>"
+
+#: index.docbook:532
+msgid "Generator"
+msgstr "identity"
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr "Utilisation de la colonne identity de DB2, MySQL, MS SQL Server, Sybase et HypersonicSQL. L'identifiant renvoyé est de type <literal>long</literal>, <literal>short</literal> ou <literal>int</literal>."
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "sequence"
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr "Utilisation des séquences dans DB2, PostgreSQL, Oracle, SAP DB, McKoi ou d'un générateur dans Interbase. L'identifiant renvoyé est de type <literal>long</literal>, <literal>short</literal> ou <literal>int</literal>"
+
+#: index.docbook:551
+msgid "increment"
+msgstr "hilo"
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "Utilise un algorithme hi/lo pour générer de façon efficace des identifiants de type <literal>long</literal>, <literal>short</literal> ou <literal>int</literal>, en prenant comme source de valeur \"hi\" une table et une colonne (par défaut <literal>hibernate_unique_key</literal> et <literal>next_hi</literal> respectivement). L'algorithme hi/lo génère des identifiants uniques pour une base de données particulière seulement."
+
+#: index.docbook:562
+msgid "identity"
+msgstr "seqhilo"
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "Utilise un algorithme hi/lo pour générer efficacement des identifiants de type <literal>long</literal>, <literal>short</literal> ou <literal>int</literal>, étant donné un nom de séquence en base."
+
+#: index.docbook:572
+msgid "sequence"
+msgstr "uuid"
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "Utilise un algorithme de type UUID 128 bits pour générer des identifiants de type string, unique au sein d'un réseau (l'adresse IP est utilisée). Le UUID en codé en une chaîne de nombre héxadécimaux de longueur 32."
+
+#: index.docbook:582
+msgid "hilo"
+msgstr "guid"
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "Utilise une chaîne GUID générée par la base pour MS SQL Server et MySQL."
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr "native"
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "Choisit <literal>identity</literal>, <literal>sequence</literal> ou <literal>hilo</literal> selon les possibilités offertes par la base de données sous-jacente."
+
+#: index.docbook:604
+msgid "uuid"
+msgstr "assigned"
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr "Laisse l'application affecter un identifiant à l'objet avant que la métode <literal>save()</literal> soit appelée. Il s'agit de la stratégie par défaut si aucun <literal><generator></literal> n'est spécifié."
+
+#: index.docbook:614
+msgid "guid"
+msgstr "select"
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr "Récupère une clef primaire assignée par un trigger en sélectionnant la ligne par une clef unique quelconque."
+
+#: index.docbook:622
+msgid "native"
+msgstr "foreign"
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "Utilise l'identifiant d'un objet associé. Habituellement utilisé en conjonction avec une association <literal><one-to-one></literal> sur la clef primaire."
+
+#: index.docbook:632
+msgid "assigned"
+msgstr "algorithme Hi/lo"
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr "Les générateurs <literal>hilo</literal> et <literal>seqhilo</literal> proposent deux implémentations alternatives de l'algorithme hi/lo, une approche largement utilisée pour générer des identifiants. La première implémentation nécessite une table \"spéciale\" en base pour héberger la prochaine valeur \"hi\" disponible. La seconde utilise une séquence de type Oracle (quand la base sous-jacente le propose)."
+
+#: index.docbook:642
+msgid "select"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:651
+msgid "foreign"
+msgstr "Malheureusement, vous ne pouvez pas utilisez <literal>hilo</literal> quand vous apportez votre propre <literal>Connection</literal> Ã Hibernate. Quand Hibernate utilise une datasource du serveur d'application pour obtenir des connexions inscrites avec JTA, vous devez correctement configurer <literal>hibernate.transaction.manager_lookup_class</literal>."
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr "UUID algorithm"
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr "Le contenu du UUID est : adresse IP, date de démarrage de la JVM (précis au quart de seconde), l'heure système et un compteur (unique au sein de la JVM). Il n'est pas possible d'obtenir l'adresse MAC ou une adresse mémoire à partir de Java, c'est donc le mieux que l'on puisse faire sans utiliser JNI."
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "Colonnes identifiantes et séquences"
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr "Pour les bases qui implémentent les colonnes \"identité\" (DB2, MySQL, Sybase, MS SQL), vous pouvez utiliser la génération de clef par <literal>identity</literal>. Pour les bases qui implémentent les séquences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) vous pouvez utiliser la génération de clef par <literal>sequence</literal>. Ces deux méthodes nécessitent deux requêtes SQL pour insérer un objet."
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "Pour le développement multi-plateformes, la stratégie <literal>native</literal> choisira entre les méthodes <literal>identity</literal>, <literal>sequence</literal> et <literal>hilo</literal>, selon les possibilités offertes par la base sous-jacente."
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "Identifiants assignés"
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr "Si vous souhaitez que l'application assigne des identifiants (par opposition à la génération par Hibernate), vous pouvez utiliser le générateur <literal>assigned</literal>. Ce générateur spécial utilisera une valeur d'identifiant déjà utilisé par la propriété identifiant l'objet. Ce générateur est utilisé quand la clef primaire est une clef naturelle plutôt qu'une clef secondaire. C'est le comportement par défaut si vous ne précisez pas d'élément <literal><generator></literal>."
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr "Choisir le générateur <literal>assigned</literal> fait utiliser <literal>unsaved-value=\"undefined\"</literal> par Hibernate, le forçant à interroger la base pour déterminer si l'instance est transiente ou détachée, à moins d'utiliser une propriété version ou timestamp, ou alors de définir <literal>Interceptor.isUnsaved()</literal>."
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr "Clefs primaires assignées par trigger"
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr "Pour les schémas de base hérités d'anciens systèmes uniquement (Hibernate ne génère pas de DDL avec des triggers)"
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr "Dans l'exemple ci-dessus, <literal>socialSecurityNumber</literal> a une valeur unique définie par la classe en tant que clef naturelle et <literal>person_id</literal> est une clef secondaire dont la valeur est générée par trigger."
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr "composite-id"
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr "Pour une table avec clef composée, vous pouvez mapper plusieurs attributs de la classe comme propriétés identifiantes. L'élement <literal><composite-id></literal> accepte les mappings de propriétés <literal><key-property></literal> et les mappings <literal><key-many-to-one></literal> comme fils."
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr "Vos classes persistantes <emphasis>doivent</emphasis> surcharger les méthodes <literal>equals()</literal> et <literal>hashCode()</literal> pour implémenter l'égalité d'identifiant composé. Elles doivent aussi implenter l'interface <literal>Serializable</literal>."
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr "Malheureusement cette approche sur les identifiants composés signifie qu'un objet persistant est son propre identifiant. Il n'y a pas d'autre moyen pratique de manipuler l'objet que par l'objet lui-même. Vous devez instancier une instance de la classe persistante elle-même et peupler ses attributs identifiants avant de pouvoir appeler la méthode <literal>load()</literal> pour charger son état persistant associé à une clef composée. Nous appelons cette approche \"identifiant composé <emphasis>embarqué</emphasis>\" et ne la recommandons pas pour des applications complexes."
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "Une seconde approche, appelée identifiant composé <emphasis>mappé</emphasis>, consiste à encapsuler les propriétés identifiantes (celles contenues dans <literal><composite-id></literal>) dans une classe particulière."
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr "Dans cet exemple, la classe d'identifiant composée,<literal>MedicareId</literal> et la classe mappée elle-même, possèdent les propriétés <literal>medicareNumber</literal> et <literal>dependent</literal>. La classe identifiante doit redéfinir <literal>equals()</literal> et <literal>hashCode()</literal> et implémenter <literal>Serializable</literal>. Le désavantage de cette approche est la duplication du code."
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr "Les attributs suivants servent à configurer un identifiant composé mappé :"
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr "<literal>mapped</literal> (optionnel, défaut à <literal>false</literal>) : indique qu'un identifiant composé mappé est utilisé, et que les propriétés contenues font référence aux deux classes (celle mappée et la classe identifiante)."
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr "<literal>class</literal> (optionnel, mais requis pour un identifiant composé mappé) : La classe composant utilisée comme identifiant composé."
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr "Nous décrirons une troisième approche beaucoup plus efficace ou l'identifiant composé est implémenté comme une classe composant dans <xref linkend=\"components-compositeid\"/>. Les attributs décrits ci dessous, ne s'appliquent que pour cette dernière approche :"
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr "<literal>name</literal> (optionnel, requis pour cette approche) : une propriété de type composant qui contient l'identifiant composé (voir chapitre 9)."
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "<literal>access</literal> (optionnel - défaut à <literal>property</literal>) : La stratégie qu'Hibernate utilisera pour accéder à la valeur de la propriété."
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr "<literal>class</literal> (optionnel - défaut au type de la propriété déterminé par réflexion) : La classe composant utilisée comme identifiant (voir prochaine section)."
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr "Cette dernière approche est celle que nous recommandons pour toutes vos applications."
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "discriminator"
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr "L'élément <literal><discriminator></literal> est nécessaire pour la persistance polymorphique qui utilise la stratégie de mapping de table par hiérarchie de classe. La colonne discriminante contient une valeur marqueur qui permet à la couche de persistance de savoir quelle sous-classe instancier pour une ligne particulière de table en base. Un nombre restreint de types peuvent être utilisés : <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr "<literal>column</literal> (optionnel - par défaut à <literal>class</literal>) le nom de la colonne discriminante."
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr "<literal>type</literal> (optionnel - par défaut à <literal>string</literal>) un nom indiquant le type Hibernate."
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr "<literal>force</literal> (optionnel - par défaut à <literal>false</literal>) \"oblige\" Hibernate à spécifier une valeur discriminante autorisée même quand on récupère toutes les instances de la classe de base."
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr "<literal>insert</literal> (optionnel - par défaut à <literal>true</literal>) à passer à <literal>false</literal> si la colonne discriminante fait aussi partie d'un identifiant composé mappé (Indique à Hibernate de ne pas inclure la colonne dans les <literal>INSERT</literal> SQL)."
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr "<literal>formula</literal> (optionnel) une expression SQL arbitraire qui est exécutée quand un type doit être évalué. Permet la discrimination basée sur le contenu."
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr "Les véritables valeurs de la colonne discriminante sont spécifiées par l'attribut <literal>discriminator-value</literal> des éléments <literal><class></literal> et <literal><subclass></literal>."
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr "L'attribut <literal>force</literal> n'est utile que si la table contient des lignes avec des valeurs \"extra\" discriminantes qui ne sont pas mappées à une classe persistante. Ce ne sera généralement pas le cas."
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr "En utilisant l'attribut <literal>formula</literal> vous pouvez déclarer une expression SQL arbitraire qui sera utilisée pour évaluer le type d'une ligne :"
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr "version (optionnel)"
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr "L'élément <literal><version></literal> est optionnel et indique que la table contient des données versionnées. C'est particulièrement utile si vous avez l'intention d'utiliser des <emphasis>transactions longues</emphasis> (voir plus-bas)."
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr "<literal>column</literal> (optionnel - par défaut égal au nom de la propriété) : Le nom de la colonne contenant le numéro de version."
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr "<literal>name</literal> : Le nom d'un attribut de la classe persistante."
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal>type</literal> (optionnel - par défaut à <literal>integer</literal>) : Le type du numéro de version."
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>) : La stratégie à utiliser par Hibernate pour accéder à la valeur de la propriété."
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr "<literal>unsaved-value</literal> (optionnel - par défaut à <literal>undefined</literal>) : Une valeur de la propriété d'identifiant qui indique que l'instance est nouvellement instanciée (non sauvegardée), et qui la distingue des instances détachées qui ont été sauvegardées ou chargées dans une session précédente (<literal>undefined</literal> indique que la valeur de l'atribut identifiant devrait être utilisé)."
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr "<literal>generated</literal> (optional - défaut à <literal>never</literal>) : Indique que la valeur de la propriété version est générée par la base de données cf. <xref linkend=\"mapping-generated\"/>generated properties."
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal>insert</literal> (optionnel - défaut à <literal>true</literal>) : Indique si la colonne de version doit être incluse dans les ordres insert. Peut être à <literal>false</literal> si et seulement si la colonne de la base de données est définie avec une valeur par défaut à <literal>0</literal>."
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr "Les numéros de version doivent avoir les types Hibernate <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> ou <literal>calendar</literal>."
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr "Une propriété de version ou un timestamp ne doit jamais être null pour une instance détachée, ainsi Hibernate pourra détecter toute instance ayant une version ou un timestamp null comme transient, quelles que soient les stratégies <literal>unsaved-value</literal> spécifiées. <emphasis>Déclarer un numéro de version ou un timestamp \"nullable\" est un moyen pratique d'éviter tout problème avec les réattachements transitifs dans Hibernate, particulièrement utile pour ceux qui utilisent des identifiants assignés ou des clefs composées !</emphasis>"
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "timestamp (optionnel)"
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr "L'élément optionnel <literal><timestamp></literal> indique que la table contient des données horodatées (timestamp). Cela sert d'alternative à l'utilisation de numéros de version. Les timestamps (ou horodatage) sont par nature une implémentation moins fiable pour l'optimistic locking. Cependant, l'application peut parfois utiliser l'horodatage à d'autres fins."
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr "<literal>column</literal> (optionnel - par défaut à le nom de la propriété) : Le nom d'une colonne contenant le timestamp."
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>) : La stratégie à utiliser par Hibernate pour accéder à la valeur de la propriété."
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr "<literal>unsaved-value</literal> (optionnel - par défaut à <literal>null</literal>) : Propriété dont la valeur est un numéro de version qui indique que l'instance est nouvellement instanciée (non sauvegardée), et qui la distingue des instances détachées qui ont été sauvegardées ou chargées dans une session précédente (<literal>undefined</literal> indique que la valeur de l'attribut identifiant devrait être utilisée)."
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr "<literal>source</literal> (optionnel - par défaut à <literal>vm</literal>) : D'où Hibernate doit-il récupérer la valeur du timestamp? Depuis la base de données ou depuis la JVM d'exécution? Les valeurs de timestamp de la base de données provoquent une surcharge puisque Hibernate doit interroger la base pour déterminer la prochaine valeur mais cela est plus sûr lorsque vous fonctionnez dans un cluster. Remarquez aussi que certains des dialectes ne supportent pas cette fonction, et que d'autres l'implémentent mal, provoquant des erreurs de précision (Oracle 8 par exemple)."
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr "<literal>generated</literal> (optional - défaut à <literal>never</literal>) : Indique que la valeur de ce timestamp est générée par la base de données cf. <xref linkend=\"mapping-generated\"/>generated properties."
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr "Notez que <literal><timestamp></literal> est équivalent à <literal><version type=\"timestamp\"></literal>."
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr "property"
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr "L'élément <literal><property></literal> déclare une propriété de la classe au sens JavaBean."
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr "<literal>name</literal> : nom de la propriété, avec une lettre initiale en minuscule."
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr "<literal>column</literal> (optionnel - par défaut au nom de la propriété) : le nom de la colonne mappée. Cela peut aussi être indiqué dans le(s) sous-élément(s) <literal><column></literal>."
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr "<literal>type</literal> (optionnel) : nom indiquant le type Hibernate."
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "<literal>update, insert</literal> (optionnel - par défaut à <literal>true</literal>) : indique que les colonnes mappées devraient être incluses dans des <literal>UPDATE</literal> SQL et/ou des <literal>INSERT</literal>. Mettre les deux à <literal>false</literal> empêche la propagation en base de données (utile si vous savez qu'un trigger affectera la valeur à la colonne)."
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr "<literal>formula</literal> (optionnel) : une expression SQL qui définit la valeur pour une propriété <emphasis>calculée</emphasis>. Les propriétés calculées ne possède pas leur propre mapping."
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>): Stratégie que Hibernate doit utiliser pour accéder à cette valeur."
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr "<literal>lazy</literal> (optionnel - par défaut à <literal>false</literal>): Indique que cette propriété devrait être chargée en différé (lazy loading) quand on accède à la variable d'instance pour la première fois."
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr "<literal>unique</literal> (optionnel): Génère le DDL d'une contrainte d'unicité pour les colonnes. Permet aussi d'en faire la cible d'un <literal>property-ref</literal>."
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "<literal>not-null</literal> (optionnel): Génère le DDL d'une contrainte de non nullité pour les colonnes."
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr "<literal>optimistic-lock</literal> (optionnel - par défaut à <literal>true</literal>): Indique que les mises à jour de cette propriété peuvent ou non nécessiter l'acquisition d'un verrou optimiste. En d'autres termes, cela détermine s'il est nécessaire d'incrémenter un numéro de version quand cette propriété est marquée obsolète (dirty)."
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr "<literal>generated</literal> (optional - défaut à <literal>never</literal>): Indique que la valeur de ce timestamp est générée par la base de données cf. <xref linkend=\"mapping-generated\"/>generated properties."
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr "<emphasis>typename</emphasis> peut être:"
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "Nom d'une classe Java avec un type basique par défaut (ex: <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "Nom d'une classe Java sérialisable."
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr "Nom d'une classe ayant un type spécifique (ex: <literal>com.illflow.type.MyCustomType</literal>)."
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "Si vous n'indiquez pas un type, Hibernate utlisera la réflexion sur le nom de la propriété pour tenter de trouver le type Hibernate correct. Hibernate essayera d'interprêter le nom de la classe retournée par le getter de la propriété en utilisant les régles 2, 3, 4 dans cet ordre. Cependant, ce n'est pas toujours suffisant. Dans certains cas vous aurez encore besoin de l'attribut <literal>type</literal> (Par exemple, pour distinguer <literal>Hibernate.DATE</literal> et <literal>Hibernate.TIMESTAMP</literal>, ou pour préciser un type spécifique)."
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr "L'attribut <literal>access</literal> permet de contrôler comment Hibernate accèdera à la propriété à l'exécution. Par défaut, Hibernate utilisera les méthodes set/get. Si vous indiquez <literal>access=\"field\"</literal>, Hibernate ignorera les getter/setter et accèdera à la propriété directement en utilisant la réflexion. Vous pouvez spécifier votre propre stratégie d'accès aux propriété en donnant une classe qui implémente l'interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr "Une fonctionnalité particulièrement intéressante est les propriétés dérivées. Ces propriétés sont par définition en lecture seule, la valeur de la propriété est calculée au chargement. Le calcul est déclaré comme une expression SQL, qui se traduit par une sous-requête <literal>SELECT</literal> dans la requête SQL qui charge une instance :"
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "Remarquez que vous pouvez référencer la propre table des entités en ne déclarant pas un alias sur une colonne particulière (<literal>customerId</literal> dans l'exemple donné). Notez aussi que vous pouvez utiliser le sous-élément de mapping <literal><formula></literal> plutôt que d'utiliser l'attribut si vous le souhaitez."
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr "many-to-one"
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "Une association ordinaire vers une autre classe persistante est déclarée en utilisant un élément <literal>many-to-one</literal>. Le modèle relationnel est une association de type many-to-one : une clef étrangère dans une table référence la ou les clef(s) primaire(s) dans la table cible."
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "<literal>name</literal> : Nom de la propriété."
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr "<literal>column</literal> (optionnel) : Le nom de la clef étrangère. Cela peut être aussi indiqué avec le sous-élément <literal><column></literal>."
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>class</literal> (optionnel - par défaut le type de la propriété déterminé par réflexion) : Le nom de la classe associée."
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr "<literal>cascade</literal> (optionnel) : Indique quelles opérations doivent être propagées de l'objet père vers les objets associés."
+
+#: index.docbook:1284
+msgid "property"
+msgstr "<literal>fetch</literal> (optionnel - par défaut à <literal>select</literal>) : Choisit entre le chargement de type outer-join ou le chargement par select successifs."
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr "<literal>update, insert</literal> (optionnel - par défaut à <literal>true</literal>) : indique que les colonnes mappées devraient être incluses dans des <literal>UPDATE</literal> SQL et/ou des <literal>INSERT</literal>. Mettre les deux à <literal>false</literal> empêche la propagation en base de données (utile si vous savez qu'un trigger affectera la valeur à la colonne)."
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr "<literal>property-ref</literal> : (optionnel) Le nom d'une propriété de la classe associée qui est liée à cette clef étrangère. Si ce n'est pas spécifié, la clef primaire de la classe associée est utilisée."
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>) : La stratégie à utiliser par Hibernate pour accéder à la valeur de cette propriété."
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>unique</literal> (optionnel) : Génère le DDL d'une contrainte d'unicité pour la clef étrangère. Permet aussi d'en faire la cible d'un <literal>property-ref</literal>. Cela permet de créer une véritable association one-to-one."
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr "<literal>not-null</literal> (optionnel) : Génère le DDL pour une contrainte de non nullité pour la clef étrangère."
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "<literal>optimistic-lock</literal> (optionnel - par défaut à <literal>true</literal>) : Indique que les mises à jour de cette propriété requièrent ou non l'acquisition d'un verrou optimiste. En d'autres termes, détermine si un incrément de version doit avoir lieu quand la propriété est marquée obsolète (dirty)."
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "<literal>lazy</literal> (optionnel - par défaut à <literal>false</literal>) : Indique que cette propriété doit être chargée en différé (lazy loading) au premier accès à la variable d'instance (nécessite une instrumentation du bytecode lors de la phase de construction). Remarquez que cela n'influence pas le comportement du proxy Hibernate - comme l'attribut <literal>lazy</literal> sur des classes ou des mappings de collections, mais utilise l'interception pour le chargement différé. <literal>lazy=\"false\"</literal> indique que l'association sera toujours chargée."
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>entity-name</literal> (optionnel) : Le nom de l'entité de la classe associée."
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>formula</literal> (optionnel) : une expression SQL qui définit la valeur pour une clé étrangère calculée."
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr "Donner une valeur significative à l'attribut <literal>cascade</literal> autre que <literal>none</literal> propagera certaines opérations à l'objet associé. Les valeurs significatives sont les noms des opérations Hibernate basiques, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, ainsi que les valeurs spéciales <literal>delete-orphan</literal> et <literal>all</literal> et des combinaisons de noms d'opérations séparées par des virgules, comme par exemple <literal>cascade=\"persist,merge,evict\"</literal> ou <literal>cascade=\"all,delete-orphan\"</literal>. Voir <xref linkend=\"objectstate-transitive\"/> pour une explication complète. Notez que les assocations many-to-one et one-to-one ne supportent pas orphan delete."
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "Une déclaration <literal>many-to-one</literal> typique est aussi simple que :"
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr "L'attribut <literal>property-ref</literal> devrait être utilisé pour mapper seulement des données provenant d'un ancien système où les clefs étrangères font référence à une clef unique de la table associée et qui n'est pas la clef primaire. C'est un cas de mauvaise conception relationnelle. Par exemple, supposez que la classe <literal>Product</literal> a un numéro de série unique qui n'est pas la clef primaire. (L'attribut <literal>unique</literal> contrôle la génération DDL par Hibernate avec l'outil SchemaExport.)"
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr "Ainsi le mapping pour <literal>OrderItem</literal> peut utiliser :"
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr "bien que ce ne soit certainement pas encouragé."
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr "Si la clef unique référencée comprend des propriétés multiples de l'entité associée, vous devez mapper ces propriétés à l'intérieur d'un élément <literal><properties></literal>."
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "one-to-one"
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "Une association one-to-one vers une autre classe persistante est déclarée avec l'élément <literal>one-to-one</literal>."
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ "/>]]>"
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr "<literal>name</literal> : Le nom de la propriété."
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr "<literal>class</literal> (optionnel - par défaut du type de la propriété déterminé par réflexion) : Le nom de la classe associée."
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "<literal>cascade</literal> (optionnel) : Indique quelles opérations doivent être cascadées de l'objet père vers l'objet associé."
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "<literal>constrained</literal> (optionnel) : Indique qu'une contrainte de clef étrangère sur la clef primaire de la table mappée référence la table de la classe associée. Cette option affecte l'ordre dans lequel chaque <literal>save()</literal> et chaque <literal>delete()</literal> sont cascadés et détermine si l'association peut utiliser un proxy (aussi utilisé par l'outil d'export de schéma)."
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr "<literal>fetch</literal> (optionnel - par défaut à <literal>select</literal>) : Choisit entre récupération par jointure externe ou select séquentiel."
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>property-ref</literal> (optionnel) : Le nom de la propriété de la classe associée qui est jointe à la clef primaire de cette classe. Si ce n'est pas spécifié, la clef primaire de la classe associée est utilisée."
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>) : La stratégie à utiliser par Hibernate pour accéder à la valeur de la propriété."
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "<literal>formula</literal> (optionnel) : Presque toutes les associations one-to-one pointent sur la clef primaire de l'entité propriétaire. Dans les rares cas différents, vous devez donner une ou plusieurs autres colonnes ou expression à joindre par une formule SQL (voir <literal>org.hibernate.test.onetooneformula</literal> pour un exemple)."
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr "<literal>lazy</literal> (optionnel - par défaut <literal>proxy</literal>) : Par défaut, les associations simples sont soumise à proxy. <literal>lazy=\"no-proxy\"</literal> spécifie que la propriété doit être chargée à la demande au premier accès à l'instance. (nécessite l'intrumentation du bytecode à la construction). <literal>lazy=\"false\"</literal> indique que l'association sera toujours chargée agressivement. <emphasis>Notez que si <literal>constrained=\"false\"</literal>, l'utilisation de proxy est impossible et Hibernate chargera automatiquement l'association !</emphasis>"
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "<literal>entity-name</literal> (optional) : The entity name of the associated class."
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr "Il existe deux types d'associations one-to-one :"
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr "association par clef étrangère unique"
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr "Les associations par clef primaire ne nécessitent pas une colonne supplémentaire en table ; si deux lignes sont liés par l'association alors les deux lignes de la table partagent la même valeur de clef primaire. Donc si vous voulez que deux objets soient liés par une association par clef primaire, vous devez faire en sorte qu'on leur assigne la même valeur d'identifiant !"
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr "Pour une association par clef primaire, ajoutez les mappings suivants à <literal>Employee</literal> et <literal>Person</literal>, respectivement."
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr "Maintenant, vous devez faire en sorte que les clefs primaires des lignes liées dans les tables PERSON et EMPLOYEE sont égales. On utilise une stratégie Hibernate spéciale de génération d'identifiants appelée <literal>foreign</literal> :"
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr "Une instance fraîchement enregistrée de <literal>Person</literal> se voit alors assignée la même valeur de clef primaire que l'instance de <literal>Employee</literal> référencée par la propriété <literal>employee</literal> de cette <literal>Person</literal>."
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr "Alternativement, une clef étrangère avec contrainte d'unicité de <literal>Employee</literal> vers <literal>Person</literal> peut être indiquée ainsi :"
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr "Et cette association peut être rendue bidirectionnelle en ajoutant ceci au mapping de <literal>Person</literal> :"
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr "natural-id"
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr "Bien que nous recommandions l'utilisation de clé primaire générée, vous devriez toujours essayer d'identifier des clé métier (naturelles) pour toutes vos entités. Une clé naturelle est une propriété ou une combinaison de propriétés uniques et non nulles. Si elle est aussi immuable, c'est encore mieux. Mappez les propriétés de la clé naturelle dans l'élément <literal><natural-id></literal>. Hibernate générera la clé unique nécessaire et les contraintes de non-nullité, et votre mapping s'auto-documentera."
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr "Nous vous recommandons fortement d'implémenter <literal>equals()</literal> et <literal>hashCode()</literal> pour comparer les clés naturelles de l'entité."
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr "Ce mapping n'est pas destiné à être utilisé avec des entités qui ont des clés naturelles."
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr "<literal>mutable</literal> (optionel, par défaut à <literal>false</literal>) : Par défaut, les identifiants naturels sont supposés être immuable (constants)."
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr "component, dynamic-component"
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr "L'élément <literal><component></literal> mappe les propriétés d'un objet fils aux colonnes d'une classe parente. Les composants peuvent en retour déclarer leurs propres propriétés, composants ou collections. Voir \"Components\" plus bas."
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+ "<![CDATA[<component \n"
+ " name=\"propertyName\" \n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ " \n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "<literal>insert</literal> : Est ce que les colonnes mappées apparaissent dans les <literal>INSERT</literal>s ?"
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr "<literal>update</literal>: Est ce que les colonnes mappées apparaissent dans les <literal>UPDATE</literal>s ?"
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr "<literal>lazy</literal> (optionnel - par défaut à <literal>false</literal>) : Indique que ce composant doit être chargé au premier accès à la variable d'instance (nécessite une instrumentation du bytecode au moment du build)."
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr "<literal>unique</literal> (optionnel - par défaut à <literal>false</literal>) : Indique qu'une contrainte d'unicité existe sur toutes les colonnes mappées de ce composant."
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr "Les tags fils <literal><property></literal> mappent les propriétés de la classe fille sur les colonnes de la table."
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr "L'élément <literal><dynamic-component></literal> permet à une <literal>Map</literal> d'être mappée comme un composant, quand les noms de la propriété font référence aux clefs de cette Map, voir <xref linkend=\"components-dynamic\"/>."
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr "properties"
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr "L'élément <literal><properties></literal> permet la définition d'un groupement logique nommé des propriétés d'une classe. L'utilisation la plus importante de cette construction est la possibilité pour une combinaison de propriétés d'être la cible d'un <literal>property-ref</literal>. C'est aussi un moyen pratique de définir une contrainte d'unicité multi-colonnes."
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr ""
+ "<![CDATA[<properties \n"
+ " name=\"logicalName\" \n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ " \n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr "<literal>name</literal> : Le nom logique d'un regroupement et <emphasis>non</emphasis> le véritable nom d'une propriété."
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr "<literal>insert</literal> : Est-ce que les colonnes mappées apparaissent dans les <literal>INSERT</literal>s ?"
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr "<literal>update</literal> : Est-ce que les colonnes mappées apparaissent dans les <literal>UPDATE</literal>s ?"
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "<literal>optimistic-lock</literal> (optionnel - par défaut à <literal>true</literal>) : Indique que les mises à jour sur ce composant nécessitent ou non l'acquisition d'un verrou optimiste. En d'autres termes, cela détermine si une incrémentation de version doit avoir lieu quand la propriété est marquée obsolète (dirty)."
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr "<literal>unique</literal> (optionnel - par défaut à <literal>false</literal>) : Indique qu'une contrainte d'unicité existe sur toutes les colonnes mappées de ce composant."
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "Par exemple, si nous avons le mapping de <literal><properties></literal> suivant :"
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\" \n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr "Alors nous pourrions avoir une association sur des données d'un ancien système (legacy) qui font référence à cette clef unique de la table <literal>Person</literal> au lieu de la clef primaire :"
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"person\" \n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr "Nous ne recommandons pas l'utilisation de ce genre de chose en dehors du contexte de mapping de données héritées d'anciens systèmes."
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr "subclass"
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr "Pour finir, la persistance polymorphique nécessite la déclaration de chaque sous-classe de la classe persistante de base. pour la stratégie de mapping de type table-per-class-hierarchy, on utilise la déclaration <literal><subclass></literal>."
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "<literal>name</literal> : Le nom complet de la sous-classe."
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr "<literal>discriminator-value</literal> (optionnel - par défaut le nom de la classe) : une valeur qui distingue les différentes sous-classes."
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr "<literal>proxy</literal> (optionnel) : Indique une classe ou interface à utiliser pour les chargements à la demande des proxies (lazy)."
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr "<literal>lazy</literal> (optionnel, par défaut à <literal>true</literal>) : Spécifier <literal>lazy=\"false\"</literal> désactive l'utilisation du chargement à la demande (lazy)."
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr "Chaque sous-classe devrait déclarer ses propres propriétés persistantes et sous-classes. Les propriétés <literal><version></literal> et <literal><id></literal> sont implicitement hérités de la classe de base. Chaque sous-classe dans une hiérarchie doit définir une unique <literal>discriminator-value</literal>. Si aucune n'est spécifiée, le nom complet de la classe Java est utilisé."
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr "Pour plus d'infos sur le mapping d'héritage, voir <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr "Pour des informations sur les mappings d'héritage, voir <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr "joined-subclass"
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr "Une autre façon possible de faire est la suivante, chaque sous-classe peut être mappée vers sa propre table (stratégie de mapping de type table-per-subclass). L'état hérité est récupéré en joignant la table de la super-classe. L'élément <literal><joined-subclass></literal> est utilisé."
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>name</literal> : Le nom Java complet de la sous-classe."
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "<literal>table</literal> : Le nom de la table de la sous-classe."
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "<literal>proxy</literal> (optionnel) : Indique une classe ou interface pour le chargement différé des proxies."
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr "<literal>lazy</literal> (optionnel, par défaut à <literal>true</literal>) : Indiquer <literal>lazy=\"false\"</literal> désactive l'utilisation du chargement à la demande."
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "Aucune colonne discriminante n'est nécessaire pour cette stratégie de mapping. Cependant, chaque sous-classe doit déclarer une colonne de table contenant l'objet identifiant qui utilise l'élément <literal><key></literal>. Le mapping au début de ce chapitre serait ré-écrit ainsi :"
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:1928
+msgid "properties"
+msgstr "Pour des informations sur les mappings d'héritage, voir <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr "union-subclass"
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr "Une troisième option est de seulement mapper vers des tables les classes concrètes d'une hiérarchie d'héritage, (stratégie de type table-per-concrete-class) où chaque table définit tous les états persistants de la classe, y compris les états hérités. Dans Hibernate il n'est absolument pas nécessaire de mapper explicitement de telles hiérarchies d'héritage. Vous pouvez simplement mapper chaque classe avec une déclaration <literal><class></literal> différente. Cependant, si vous souhaitez utiliser des associations polymorphiques (cà d une association vers la superclasse de la hiérarchie), vous devez utiliser le mapping <literal><union-subclass></literal>."
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr "<literal>proxy</literal> (optionnel) : Indique une classe ou interface pour le chargement différé des proxies."
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr "Aucune colonne discriminante ou colonne clef n'est requise pour cette stratégie de mapping."
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr "Pour des informations sur les mappings d'héritage, voir <xref linkend=\"inheritance\"/>."
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "join"
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr "En utilisant l'élément <literal><join></literal>, il est possible de mapper des propriétés d'une classe sur plusieurs tables."
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optionnel=\"true|false\">\n"
+ " \n"
+ " <key ... />\n"
+ " \n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr "<literal>table</literal> : Le nom de la table jointe."
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr "<literal>schema</literal> (optionnel) : court-circuite le nom de schéma spécifié par l'élément de base <literal><hibernate-mapping></literal>."
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr "<literal>catalog</literal> (optionnel) : court-circuite le nom de catalogue spécifié par l'élément de base <literal><hibernate-mapping></literal>."
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr "<literal>fetch</literal> (optionnel - par défaut à <literal>join</literal>) : Si positionné à <literal>join</literal>, Hibernate utilisera une jointure interne pour charger une <literal>jointure</literal> définie par une classe ou ses super-classes et une jointure externe pour une <literal><jointure></literal> définie par une sous-classe. Si positionné à <literal>select</literal> alors Hibernate utilisera un select séquentiel pour une <literal><jointure></literal> définie sur une sous-classe, qui ne sera délivrée que si une ligne se représente une instance de la sous-classe. Les jointures internes seront quand même utilisées pour charger une <literal><jointure></literal> définie par une classe et ses super-classes."
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr "<literal>inverse</literal> (optionnel - par défaut à <literal>false</literal>) : Si positionné à true, Hibernate n'essaiera pas d'insérer ou de mettre à jour les propriétés définies par cette jointure."
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr "<literal>optionnel</literal> (optionnel - par défaut à <literal>false</literal>) : Si positionné à true, Hibernate insèrera une ligne seulement si les propriétés définies par cette jointure sont non-nulles et utilisera toujours une jointure externe pour charger les propriétés."
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "Par exemple, les informations d'adresse pour une personne peuvent être mappées vers une table séparée (tout en préservant des sémantiques de type valeur pour toutes ses propriétés) :"
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr "Cette fonctionnalité est souvent seulement utile pour les modèles de données hérités d'anciens systèmes (legacy), nous recommandons d'utiliser moins de tables que de classes et un modèle de domaine à granularité fine. Cependant, c'est utile pour passer d'une stratégie de mapping d'héritage à une autre dans une hiérarchie simple ainsi qu'il est expliqué plus tard."
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr "<title>key</title>"
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr "Nous avons rencontré l'élément <literal><key></literal> à plusieurs reprises maintenant. Il apparaît partout que l'élément de mapping parent définit une jointure sur une nouvele table, et définit la clef étrangère dans la table jointe, ce qui référence la clef primaire de la table d'origine."
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr "<literal>on-delete</literal> (optionnel, par défaut à <literal>noaction</literal>) : Indique si la contrainte de clef étrangère possède la possibilité au niveau base de données de suppression en cascade."
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr "<literal>update</literal> (optionnel) : Indique que la clef étrangère ne devrait jamais être mise à jour (implicite si celle-ci fait partie de la clef primaire)."
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "<literal>unique</literal> (optionnel) : Indique que la clef étrangère doit posséder une contrainte d'unicité (implicite si la clef étrangère est aussi la clef primaire)."
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr "Les attributs <literal>not-null</literal> et <literal>update</literal> sont utiles pour mapper une association one-to-many unidirectionnelle. Si vous mappez un one-to-many unidirectionnel vers une clef étrangère non nulle, vous <emphasis>devez</emphasis> déclarer la colonne de la clef en utilisant <literal><key not-null=\"true\"></literal>."
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr "éléments column et formula"
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr "Tout élément de mapping qui accepte un attribut <literal>column</literal> acceptera alternativement un sous-élément <literal><column></literal>. De façon identique, <literal><formula></literal> est une alternative à l'attribut <literal>formula</literal>."
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr "import"
+
+#: index.docbook:2179
+msgid "join"
+msgstr "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr "<literal>class</literal> : Nom Java complet de la classe."
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr "<literal>rename</literal> (optionnel - par défaut vaut le nom de la classe Java (sans package)) : Nom pouvant être utilisé dans le langage de requête."
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr "L'attribut <literal>meta-type</literal> permet à l'application de spécifier un type personnalisé qui mappe des valeurs de colonnes de le base de données sur des classes persistantes qui ont un attribut identifiant du type spécifié par <literal>id-type</literal>. Vous devez spécifier le mapping à partir de valeurs du méta-type sur les noms des classes."
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr "<literal>name</literal> : le nom de la propriété."
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr "<literal>id-type</literal> : le type identifiant."
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "<literal>meta-type</literal> (optionnel - par défaut à <literal>string</literal>) : Tout type permis pour un mapping par discriminateur."
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr "<literal>cascade</literal> (optionnel - par défaut à <literal>none</literal>) : le style de cascade."
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr "<literal>access</literal> (optionnel - par défaut à <literal>property</literal>) : La stratégie à utiliser par Hibernate pour accéder à cette propriété."
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr "<literal>optimistic-lock</literal> (optionnel - par défaut à <literal>true</literal>) : Indique que les mises à jour sur cette propriété nécessitent ou non l'acquisition d'un verrou optimiste. En d'autres termes, définit si un incrément de version doit avoir lieu quand cette propriété est marquée dirty."
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr "Entités et valeurs"
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr "Pour comprendre le comportement des différents objets Java par rapport au service de persistance, nous avons besoin de les classer en deux groupes :"
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "Une <emphasis>entité</emphasis> existe indépendamment de tout autre objet possédant une référence vers l'entité. Comparez cela avec le modèle Java habituel où un objet est supprimé par le garbage collector dès qu'il n'est plus référencé. Les entités doivent être explicitement enregistrées et supprimées (sauf dans les cas où sauvegardes et suppressions sont <emphasis>cascadées</emphasis> d'une entité mère vers ses enfants). C'est différent du modèle ODMG de persistance par atteignabilité - et correspond mieux à la façon dont les objets sont habituellement utilisés dans des grands systèmes. Les entités permettent les références circulaires et partagées. Elles peuvent aussi être versionnées."
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "L'état persistant d'une entité consiste en des références vers d'autres entités et instances de types <emphasis>valeurs</emphasis>. Ces valeurs sont des types primitifs, des collections (et non le contenu d'une collection), des composants de certains objets immuables. Contrairement aux entités, les valeurs (et en particulier les collections et composants) <emphasis>sont</emphasis> persistés par atteignabiliité. Comme les valeurs (et types primitifs) sont persistés et supprimés avec l'entité qui les contient, ils ne peuvent pas posséder leurs propres versions. Les valeurs n'ont pas d'identité indépendantes, ainsi elles ne peuvent pas être partagées par deux entités ou collections."
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr "Jusqu'à présent nous avons utilisé le terme \"classe persistante\" pour parler d'entités. Nous allons continuer à faire ainsi. Cependant, au sens strict, toutes les classes définies par un utilisateur possédant un état persistant ne sont pas des entités. Un <emphasis>composant</emphasis> est une classe définie par un utilisateur avec les caractéristiques d'une valeur. Une propriété Java de type <literal>java.lang.String</literal> a aussi les caractéristiques d'une valeur. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "Nous nous pencherons sur ces deux concepts tout au long de la documentation."
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr "Le défi est de mapper les type Javas (et la définition des développeurs des entités et valeurs types) sur les types du SQL ou des bases de données. Le pont entre les deux systèmes est proposé par Hibernate : pour les entités nous utilisons <literal><class></literal>, <literal><subclass></literal> et ainsi de suite. Pour les types valeurs nous utilisons <literal><property></literal>, <literal><component></literal>, etc., habituellement avec un attribut <literal>type</literal>. La valeur de cet attribut est le nom d'un <emphasis>type de mapping</emphasis> Hibernate. Hibernate propose de base de nombreux mappings (pour les types de valeurs standards du JDK). Vous pouvez écrire vos propres types de mappings et implémenter aussi vos propres stratégies de conversion, nous le verrons plus tard."
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr "Tous les types proposés de base par Hibernate à part les collections autorisent la valeur null."
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr "Basic value types"
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr "Les <emphasis>types basiques de mapping</emphasis> proposés de base peuvent grossièrement être rangés dans les catégories suivantes :"
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "Les mappings de type des primitives Java ou leurs classes wrappers (ex: Integer pour int) vers les types SQL (propriétaires) appropriés. <literal>boolean, yes_no</literal>et <literal>true_false</literal> sont tous des alternatives pour les types Java <literal>boolean</literal> ou <literal>java.lang.Boolean</literal>."
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr "string"
+
+#: index.docbook:2367
+msgid "import"
+msgstr "Mapping de type de <literal>java.lang.String</literal> vers <literal>VARCHAR</literal> (ou le <literal>VARCHAR2</literal> Oracle)."
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr "date, time, timestamp"
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr "Mappings de type pour <literal>java.util.Date</literal> et ses sous-classes vers les types SQL <literal>DATE</literal>, <literal>TIME</literal> et <literal>TIMESTAMP</literal> (ou équivalent)."
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr "calendar, calendar_date"
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr "Mappings de type pour <literal>java.util.Calendar</literal> vers les types SQL <literal>TIMESTAMP</literal> et <literal>DATE</literal> (ou équivalent)."
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr "big_decimal, big_integer"
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr "Mappings de type pour <literal>java.math.BigDecimal</literal> et <literal>java.math.BigInteger</literal> vers <literal>NUMERIC</literal> (ou le <literal>NUMBER</literal> Oracle)."
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr "locale, timezone, currency"
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "Mappings de type pour <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> et <literal>java.util.Currency</literal> vers <literal>VARCHAR</literal> (ou le <literal>VARCHAR2</literal> Oracle). Les instances de <literal>Locale</literal> et <literal>Currency</literal> sont mappées sur leurs codes ISO. Les instances de <literal>TimeZone</literal> sont mappées sur leur <literal>ID</literal>."
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr "<literal>class</literal>"
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr "Un type de mapping pour <literal>java.lang.Class</literal> vers <literal>VARCHAR</literal> (ou le <literal>VARCHAR2</literal> Oracle). Un objet <literal>Class</literal> est mappé sur son nom Java complet."
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr "binary"
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr "Mappe les tableaux de bytes vers le type binaire SQL approprié."
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr "text"
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "Mappe les longues chaînes de caractères Java vers les types SQL <literal>CLOB</literal> ou <literal>TEXT</literal>."
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr "Mappe les types Java sérialisables vers le type SQL binaire approprié. Vous pouvez aussi indiquer le type Hibernate <literal>serializable</literal> avec le nom d'une classe Java sérialisable ou une interface qui ne soit pas par défaut un type de base."
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr "clob, blob"
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr "Mappings de type pour les classes JDBC <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. Ces types peuvent ne pas convenir pour certaines applications car un objet blob ou clob peut ne pas être réutilisable en dehors d'une transaction (de plus l'implémentation par les pilotes est moyennement bonne)."
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr "Mappings de type pour ceux qui sont habituellement modifiable, pour lesquels Hibernate effectue certains optimisations convenant seulement aux types Java immuables, et l'application les traite comme immuable. Par exemple, vous ne devriez pas appeler <literal>Date.setTime()</literal> sur une instance mappée sur un <literal>imm_timestamp</literal>. Pour changer la valeur de la propriété, et faire que cette modification soit persistée, l'application doit assigner un nouvel (non identique) objet à la propriété."
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "Les identifiants uniques des entités et collections peuvent être de n'importe quel type de base excepté <literal>binary</literal>, <literal>blob</literal> et <literal>clob</literal> (les identifiants composites sont aussi permis, voir plus bas)."
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr "Les types de base des valeurs ont des <literal>Type</literal> constants correspondants définis dans <literal>org.hibernate.Hibernate</literal>. Par exemple, <literal>Hibernate.STRING</literal> représenté le type <literal>string</literal>."
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr "Types de valeur définis par l'utilisateur"
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr "Il est assez facile pour les développeurs de créer leurs propres types de valeurs. Par exemple, vous pourriez vouloir persister des propriétés du type <literal>java.lang.BigInteger</literal> dans des colonnnes <literal>VARCHAR</literal>. Hibernate ne procure pas par défaut un type pour cela. Mais les types que vous pouvez créer ne se limitent pas à mapper des propriétés (ou élément collection) à une simple colonne d'une table. Donc, par exemple, vous pourriez avoir une propriété Java <literal>getName()</literal>/<literal>setName()</literal> de type <literal>java.lang.String</literal> persistée dans les colonnes <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr "Pour implémenter votre propre type, vous pouvez soit implémenter <literal>org.hibernate.UserType</literal> soit <literal>org.hibernate.CompositeUserType</literal> et déclarer des propriétés utilisant des noms de classes complets du type. Regardez <literal>org.hibernate.test.DoubleStringType</literal> pour voir ce qu'il est possible de faire."
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr "Remarquez l'utilisation des tags <literal><column></literal> pour mapper une propriété sur des colonnes multiples."
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr "Les interfaces <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, et <literal>UserVersionType</literal> permettent des utilisations plus spécialisées."
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "Vous pouvez même donner des paramètres en indiquant <literal>UserType</literal> dans le fichier de mapping ; Pour cela, votre <literal>UserType</literal> doit implémenter l'interface <literal>org.hibernate.usertype.ParameterizedType</literal>. Pour spécifier des paramètres dans votre type propre, vous pouvez utiliser l'élément <literal><type></literal> dans vos fichiers de mapping."
+
+#: index.docbook:2567
+msgid "string"
+msgstr ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr "Le <literal>UserType</literal> permet maintenant de récupérer la valeur pour le paramètre nommé <literal>default</literal> à partir de l'objet <literal>Properties</literal> qui lui est passé."
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr "Si vous utilisez fréquemment un <literal>UserType</literal>, cela peut être utile de lui définir un nom plus court. Vous pouvez faire cela en utilisant l'élément <literal><typedef></literal>. Les typedefs permettent d'assigner un nom à votre type propre et peuvent aussi contenir une liste de valeurs de paramètres par défaut si ce type est paramétré."
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "Il est aussi possible de redéfinir les paramètres par défaut du typedef au cas par cas en utilisant des paramètres type sur le mapping de la propriété."
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr "Bien que le fait que Hibernate propose de base une riche variété de types, et qu'il supporte les composants signifie que vous aurez très rarement <emphasis>besoin</emphasis> d'utiliser un nouveau type propre, il est néanmoins de bonne pratique d'utiliser des types propres pour les classes (non entités) qui apparaissent fréquemment dans votre application. Par exemple une classe <literal>MonetaryAmount</literal> est un bon candidat pour un <literal>CompositeUserType</literal> même s'il pourrait facilement être mappé comme un composant. Une motivation pour cela est l'abstraction. Avec un type propre vos documents de mapping sont à l'abri des changements futurs dans votre façon de représenter des valeurs monétaires."
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "Mapper une classe plus d'une fois"
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr "Il est possible de proposer plus d'un mapping par classe persistante. Dans ce cas, vous devez spécifier un <emphasis>nom d'entité</emphasis> pour lever l'ambiguité entre les instances des entités mappées (par défaut, le nom de l'entité est celui de la classe). Hibernate vous permet de spécifier le nom de l'entité lorsque vous utilisez des objets persistants, lorsque vous écrivez des requêtes ou quand vous mappez des associations vers les entités nommées."
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\" \n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\" \n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\" \n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\" \n"
+ " column=\"currentContractId\" \n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr "Remarquez comment les associations sont désormais spécifiées en utilisant <literal>entity-name</literal> au lieu de <literal>class</literal>."
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr "SQL quoted identifiers"
+
+#: index.docbook:2630
+msgid "binary"
+msgstr "Vous pouvez forcer Hibernate à mettre un identifiant entre quotes dans le SQL généré en mettant le nom de la table ou de la colonne entre backticks dans le document de mapping. Hibernate utilisera les bons styles de quotes pour le <literal>Dialect</literal> SQL (habituellement des doubles quotes, mais des parenthèses pour SQL server et des backticks pour MySQL)."
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:2638
+msgid "text"
+msgstr "alternatives Metadata"
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr "XML ne convient pas à tout le monde, il y a donc des moyens alternatifs pour définir des metatda de mappings O/R dans Hibernate."
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr "utilisation de XDoclet"
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr "De nombreux utilisateurs de Hibernate préfèrent embarquer les informations de mappings directement au sein du code source en utilisant les tags XDoclet <literal>@hibernate.tags</literal>. Nous ne couvrons pas cette approche dans ce document cependant, puisque c'est considéré comme faisant partie de XDoclet. Cependant, nous présentons l'exemple suivant de la classe <literal>Cat</literal> avec des mappings XDoclet."
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr "Voyez le site web de Hibernate pour plus d'exemples sur XDoclet et Hibernate."
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr "Utilisation des annotations JDK 5.0"
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr "Le JDK 5.0 introduit des annotations proches de celles de XDoclet au niveau java, qui sont type-safe et vérifiées à la compilation. Ce mécanisme est plus puissant que XDoclet et mieux supporté par les outils et IDE. IntelliJ IDEA, par exemple, supporte l'auto-complétion et le surlignement syntaxique des annotations JDK 5.0. La nouvelle révision des spécifications des EJB (JSR-220) utilise les annotations JDK 5.0 comme mécanisme primaire pour les meta-données des beans entités. Hibernate3 implémente l'<literal>EntityManager</literal> de la JSR-220 (API de persistance), le support du mapping de meta-données est disponible via le package <emphasis>Hibernate Annotations</emphasis>, en tant que module séparé à télécharger. EJB3 (JSR-220) et les métadata Hibernate3 sont supportés."
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr "Ceci est un exemple d'une classe POJO annotée comme un EJB entité :"
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr "Notez que le support des annotations JDK 5.0 (et de la JSR-220) est encore en cours et n'est pas terminé. Référez vous au module Hibernate Annotation pour plus de détails."
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr "Propriétés générées"
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr "Les propriétés générées sont des propriétés dont les valeurs sont générées par la base de données. Typiquement, les applications Hibernate avaient besoin d'invoquer <literal>refresh</literal> sur les instances qui contenaient des propriétés pour lesquelles la base de données générait des valeurs. Marquer les propriétés comme générées permet à l'application de déléguer cette responsabilité à Hibernate. Principalement, à chaque fois qu'Hibernate réalise une insertion ou une mise à jour en base de données pour une entité marquée comme telle, cela provoque immédiatement un select pour récupérer les valeurs générées."
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr "Les propriétés marquées comme générées doivent de plus ne pas être insérables et modifiables Seuls <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, et <xref linkend=\"mapping-declaration-property\"/>simple properties peuvent être marqués comme générées."
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr "<literal>never</literal> (par défaut) - indique la valeur de la propriété n'est pas générée dans la base de données."
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr "<literal>insert</literal> - indique que la valeur de la propriété donnée est générée à l'insertion mais pas lors des futures mises à jour de l'enregistrement. Les colonnes de type \"date de création\" sont le cas d'utilisation typique de cette option. Notez que même les propriétés <xref linkend=\"mapping-declaration-version\"/>version et <xref linkend=\"mapping-declaration-timestamp\"/>timestamp peuvent être déclarées comme générées, cette option n'est pas disponible à cet endroit..."
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr "<literal>always</literal> - indique que la valeur de la propriété est générée à l'insert comme aux updates."
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr "Objets auxiliaires de la base de données"
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr "Permettent les ordres CREATE et DROP d'objets arbitraire de la base de donnéées, en conjonction avec les outils Hibernate d'évolutions de schéma, pour permettre de définir complètement un schéma utilisateur au sein des fichiers de mapping Hibernate. Bien que conçu spécifiquement pour créer et supprimer des objets tels que des triggers et des procédures stockées, ou toute commande pouvant être exécutée via une méthode de <literal>java.sql.Statement.execute()</literal> (ALTERs, INSERTS, etc). Il y a principalement deux modes pour définir les objets auxiliaires de base de données..."
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr "Le premier mode est de lister explicitement les commandes CREATE et DROP dans le fichier de mapping:"
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr "Le second mode est de fournir une classe particulière qui connait comment construire les commandes CREATE et DROP. Cette classe particulière doit implémenter l'interface <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal>."
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr "Additionnellement, ces objets de base de données peuvent être optionnellement traités selon l'utilisation de dialectes particuliers.."
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr ""
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr ""
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr ""
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,365 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr "Traitement par paquet"
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr "Une approche naïve pour insérer 100 000 lignes dans la base de données en utilisant Hibernate pourrait ressembler à ça :"
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr "Ceci devrait s'écrouler avec une <literal>OutOfMemoryException</literal> quelque part aux alentours de la 50 000ème ligne. C'est parce qu'Hibernate cache toutes les instances de <literal>Customer</literal> nouvellement insérées dans le cache de second niveau."
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr "Dans ce chapitre nous montrerons comment éviter ce problème. D'abord, cependant, si vous faites des traitements par batch, il est absolument critique que vous activiez l'utilisation ds paquet JDBC (NdT : JDBC batching), si vous avez l'intention d'obtenir des performances raisonnables. Configurez la taille du paquet JDBC avec un nombre raisonnable (disons, 10-50) :"
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr "Vous pourriez aussi vouloir faire cette sorte de travail dans un traitement où l'interaction avec le cache de second niveau est complètement désactivé :"
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr "Insertions en paquet"
+
+#: index.docbook:41
+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 "Lorsque vous rendez des nouveaux objets persistants, vous devez régulièrement appeler <literal>flush()</literal> et puis <literal>clear()</literal> sur la session, pour contrôler la taille du cache de premier niveau."
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, même taille que la taille du paquet JDBC\n"
+ " //flush un paquet d'insertions et libère la mémoire :\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr "Paquet de mises à jour"
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Pour récupérer et mettre à jour des données les mêmes idées s'appliquent. En plus, vous avez besoin d'utiliser <literal>scroll()</literal> pour tirer partie des curseurs côté serveur pour les requêtes qui retournent beaucoup de lignes de données."
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush un paquet de mises à jour et libère la mémoire :\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:62
+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 "L'interface StatelessSession"
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Alternativement, Hibernate fournit une API orientée commande qui peut être utilisée avec des flux de données pour et en provenance de la base de données sous la forme d'objets détachés. Une <literal>StatelessSession</literal> n'a pas de contexte de persistance associé et ne fournit pas beaucoup de sémantique de durée de vie de haut niveau. En particulier, une session sans état n'implémente pas de cache de premier niveau et n'interagit pas non plus avec un cache de seconde niveau ou un cache de requêtes. Elle n'implémente pas les transactions ou la vérification sale automatique (NdT : automatic dirty checking). Les opérations réalisées avec une session sans état ne sont jamais répercutées en cascade sur les instances associées. Les collections sont ignorées par une session sans état. Les opérations exécutées via une session sans état outrepasse le modèle d'événements d'Hibernate et les intercepteurs. Les sessions sans état sont vulnér!
ables aux effets de modification des données, ceci est dû au manque de cache de premier niveau. Une session sans état est une abstraction bas niveau, plus proche de la couche JDBC sous-jacente."
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr "Notez que dans le code de l'exemple, les intances de <literal>Customer</literal> retournées par la requête sont immédiatement détachées. Elles ne sont jamais associées à un contexte de persistance."
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "Les opérations <literal>insert()</literal>, <literal>update()</literal> et <literal>delete()</literal> définies par l'interface <literal>StatelessSession</literal> sont considérées comme des opérations d'accès direct aux lignes de la base de données, ce qui résulte en une exécution immédiate du SQL <literal>INSERT</literal>, <literal>UPDATE</literal> ou <literal>DELETE</literal> respectif. De là , elles ont des sémantiques tres différentes des opérations <literal>save()</literal>, <literal>saveOrUpdate()</literal> et <literal>delete()</literal> définies par l'interface <literal>Session</literal>."
+
+#: index.docbook:91
+msgid "Note that 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 "Opérations de style DML"
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr "Comme déjà discuté avant, le mapping objet/relationnel automatique et transparent est intéressé par la gestion de l'état de l'objet. Ceci implique que l'état de l'objet est disponible en mémoire, d'où manipuler (en utilisant des expressions du langage de manipulation de données - <literal>Data Manipulation Language</literal> (DML) - SQL) les données directement dans la base n'affectera pas l'état en mémoire. Pourtant, Hibernate fournit des méthodes pour l'exécution d'expression DML de style SQL lesquelles sont réalisées à travers le langage de requête d'Hibernate (<xref linkend=\"queryhql\"/>HQL)."
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr "La pseudo-syntaxe pour les expressions <literal>UPDATE</literal> et <literal>DELETE</literal> est : <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Certains points sont à noter :"
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr "Dans la clause from, le mot-clef FROM est optionnel"
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr "Il ne peut y avoir qu'une seule entité nommée dans la clause from ; elle peut optionnellement avoir un alias. Si le nom de l'entité a un alias, alors n'importe quelle référence de propriété doit être qualifiée en ayant un alias ; si le nom de l'entité n'a pas d'alias, alors il est illégal pour n'importe quelle référence de propriété d'être qualifiée."
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr "Aucune jointure (implicite ou explicite) ne peut être spécifiée dans une requête HQL. Les sous-requêtes peuvent être utilisées dans la clause where ; les sous-requêtes, elles-mêmes, peuvent contenir des jointures."
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 "La clause where est aussi optionnelle."
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr "Par exemple, pour exécuter un <literal>UPDATE</literal> HQL, utilisez la méthode <literal>Query.executeUpdate()</literal> (la méthode est données pour ceux qui sont familiers avec <literal>PreparedStatement.executeUpdate()</literal> de JDBC) :"
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// ou String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:156
+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 "Pour exécuter un <literal>DELETE</literal> HQL, utilisez la même méthode <literal>Query.executeUpdate()</literal> :"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 "La valeur du <literal>int</literal> retourné par la méthode <literal>Query.executeUpdate()</literal> indique le nombre d'entités affectées par l'opération. Considérez que cela peut ou pas corréler le nombre de lignes affectés dans la base de données. Une opération HQL pourrait entraîner l'exécution de multiples expressions SQL réelles, pour des classes filles mappées par jointure (NdT: join-subclass), par exemple. Le nombre retourné indique le nombre d'entités réelles affectées par l'expression. Retour à l'exemple de la classe fille mappée par jointure, un effacement d'une des classes filles peut réellement entraîner des suppressions pas seulement dans la table qui mappe la classe fille, mais aussi dans la table \"racine\" et potentillement dans les tables des classes filles plus bas dans la hiérarchie d'héritage."
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "La pseudo-syntaxe pour l'expression <literal>INSERT</literal> est : <literal>INSERT INTO EntityName properties_list select_statement</literal>. Quelques points sont à noter :"
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr "Seule la forme INSERT INTO ... SELECT ... est supportée ; pas la forme INSERT INTO ... VALUES ... ."
+
+#: index.docbook:181
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr "La properties_list est analogue à la <literal>spécification de la colonne</literal> The properties_list is analogous to the <literal>column speficiation</literal> dans l'expression SQL <literal>INSERT</literal>. Pour les entités impliquées dans un héritage mappé, seules les propriétés directement définies à ce niveau de classe donné peuvent être utilisées dans properties_list. Les propriétés de la classe mère ne sont pas permises ; et les propriétés des classes filles n'ont pas de sens. En d'autres mots, les expressions <literal>INSERT</literal> par nature non polymorphiques."
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "select_statement peut être n'importe quelle requête de sélection HQl valide, avec l'avertissement que les types de retour doivent correspondre aux types attendus par l'insertion. Actuellement, c'est vérifié durant la compilation de la requête plutôt que la vérification soit reléguée à la base de données. Notez cependant que cela pourrait poser des problèmes entre les <literal>Type</literal>s d'Hibernate qui sont <emphasis>équivalents</emphasis> opposé à <emphasis>égaux</emphasis>. Cela pourrait poser des problèmes avec des disparités entre une propriété définie comme un <literal>org.hibernate.type.DateType</literal> et une propriété définie comme un <literal>org.hibernate.type.TimestampType</literal>, même si la base de données ne ferait pas de distinction ou ne serait pas capable de gérer la conversion."
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr "Pour la propriéte id, l'expression d'insertion vous donne deux options. Vous pouvez soit spécifier explicitement la propriété id dans properties_list (auquel cas sa valeur est extraite de l'expression de sélection correspondante), soit l'omettre de properties_list (auquel cas une valeur générée est utilisée). Cette dernière option est seulement disponible en utilisant le générateur d'identifiant qui opère dans la base de données ; tenter d'utiliser cette option avec n'importe quel type de générateur \"en mémoire\" causera une exception durant l'analyse. Notez que pour les buts de cette discussion, les générateurs \"en base\" sont considérés être <literal>org.hibernate.id.SequenceGenerator</literal> (et ses classes filles) et n'importe quelles implémentations de <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal>. L'exception la plus notable ici est <literal>org.hibernate.id.TableHiLoGenerator</literal>, qu ne peut pas être utili!
sée parce qu'il ne propose pas un moyen de d'exposer ses valeurs par un select."
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr "Pour des propriétés mappées comme <literal>version</literal> ou <literal>timestamp</literal>, l'expression d'insertion vous donne deux options. Vous pouvez soit spécifier la propriété dans properties_list (auquel cas sa valeur est extraite des expressions select correspondantes), soit l'omettre de properties_list (auquel cas la <literal>valeur de graine</literal> (NdT : seed value) définie par le <literal>org.hibernate.type.VersionType</literal> est utilisée)."
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr "Un exemple d'exécution d'une expression <literal>INSERT</literal> HQL :"
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:220
+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. Note however that this might 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 ""
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ""
+
+#: index.docbook:247
+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 ""
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr "Meilleures pratiques"
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr "Découpez finement vos classes et mappez les en utilisant <literal><component></literal>."
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr "Utilisez une classe <literal>Adresse</literal> pour encapsuler <literal>Rue</literal>, <literal>Region</literal>, <literal>CodePostal</literal>. Ceci permet la réutilisation du code et simplifie la maintenance."
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr "Déclarez des propriétés d'identifiants dans les classes persistantes."
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr "Hibernate rend les propriétés d'identifiants optionnelles. Il existe beaucoup de raisons pour lesquelles vous devriez les utiliser. Nous recommandons que vous utilisiez des identifiants techniques (générés, et sans connotation métier)."
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr "Identifiez les clefs naturelles."
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr "Identifiez les clefs naturelles pour toutes les entités, et mappez les avec <literal><natural-id></literal>. Implémentez <literal>equals()</literal> et <literal>hashCode()</literal> pour comparer les propriétés qui composent la clef naturelle."
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr "Placez chaque mapping de classe dans son propre fichier."
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr "N'utilisez pas un unique document de mapping. Mappez <literal>com.eg.Foo</literal> dans le fichier <literal>com/eg/Foo.hbm.xml</literal>. Cela prend tout son sens lors d'un travail en équipe."
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr "Chargez les mappings comme des ressources."
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr "Déployez les mappings en même temps que les classes qu'ils mappent."
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr "Pensez à externaliser les chaînes de caractères."
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr "Ceci est une bonne habitude si vos requêtes appellent des fonctions SQL qui ne sont pas au standard ANSI. Cette externalisation dans les fichiers de mapping rendra votre application plus portable."
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr "Utilisez les variables \"bindées\"."
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr "Comme en JDBC, remplacez toujours les valeurs non constantes par \"?\". N'utilisez jamais la manipulation des chaînes de caractères pour remplacer des valeurs non constantes dans une requête ! Encore mieux, utilisez les paramètres nommés dans les requêtes."
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr "Ne gérez pas vous même les connexions JDBC."
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr "Hibernate laisse l'application gérer les connexions JDBC. Vous ne devriez gérer vos connexions qu'en dernier recours. Si vous ne pouvez pas utiliser les systèmes de connexions livrés, réfléchissez à l'idée de fournir votre propre implémentation de <literal>org.hibernate.connection.ConnectionProvider</literal>."
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr "Pensez à utiliser les types utilisateurs."
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr "Supposez que vous ayez une type Java, de telle bibliothèque, qui a besoin d'être persisté mais qui ne fournit pas les accesseurs nécessaires pour le mapper comme composant. Vous devriez implémenter <literal>org.hibernate.UserType</literal>.Cette approche libère le code de l'application de l'implémentation des transformations vers / depuis les types Hibernate."
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr "Utilisez du JDBC pur dans les goulets d'étranglement."
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr "Dans certaines parties critiques de votre système d'un point de vue performance, quelques opérations peuvent tirer partie d'un appel JDBC natif. Mais attendez de <emphasis>savoir</emphasis> que c'est un goulet d'étranglement. Ne supposez jamais qu'un appel JDBC sera forcément plus rapide. Si vous avez besoin d'utiliser JDBC directement, ouvrez une <literal>Session</literal> Hibernate et utilisez la connexion SQL sous-jacente. Ainsi vous pourrez utiliser la même stratégie de transation et la même gestion des connexions."
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr "Comprendre le flush de <literal>Session</literal>."
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr "De temps en temps la Session synchronise ses états persistants avec la base de données. Les performances seront affectées si ce processus arrive trop souvent. Vous pouvez parfois minimiser les flush non nécessaires en désactivant le flush automatique ou même en changeant l'ordre des opérations menées dans une transaction particulière."
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr "Dans une architecture à trois couches, pensez à utiliser <literal>saveOrUpdate()</literal>."
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr "Quand vous utilisez une architecture à base de servlet / session bean, vous pourriez passer des objets chargés dans le bean session vers et depuis la couche servlet / JSP. Utilisez une nouvelle session pour traiter chaque requête. Utilisez <literal>Session.merge()</literal> ou <literal>Session.saveOrUpdate()</literal> pour synchroniser les objets avec la base de données."
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr "Dans une architecture à deux couches, pensez à utiliser la déconnexion de session."
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr "Les transactions de bases de données doivent être aussi courtes que possible pour une meilleure montée en charge.Cependant, il est souvent nécessaire d'implémenter de longues <emphasis>transactions applicatives</emphasis>, une simple unité de travail du point de vue de l'utilisateur. Une transaction applicative peut s'étaler sur plusieurs cycles de requêtes/réponses du client. Il est commun d'utiliser des objets détachés pour implémenter des transactions applicatives. Une alternative, extrêmement appropriée dans une architecture à 2 couches, est de maintenir un seul contact de persistance ouvert (session) pour toute la durée de vie de la transaction applicative et simplement se déconnecter de la connexion JDBC à la fin de chaque requête, et se reconnecter au début de la requête suivante. Ne partagez jamais une seule session avec plus d'une transaction applicative, ou vous travaillerez avec des données périmées."
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr "Considérez que les exceptions ne sont pas rattrapables."
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr "Il s'agit plus d'une pratique obligatoire que d'une \"meilleure pratique\". Quand une exception intervient, il faut faire un rollback de la <literal>Transaction</literal> et fermer la <literal>Session</literal>. Sinon, Hibernate ne peut garantir l'intégrité des états persistants en mémoire. En particulier, n'utilisez pas <literal>Session.load()</literal> pour déterminer si une instance avec un identifiant donné existe en base de données, utilisez <literal>Session.get()</literal> ou un requête."
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr "Préférez le chargement tardif des associations."
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr "Utilisez le chargement complet avec modération. Utilisez les proxies et les collections chargées tardivement pour la plupart des associations vers des classes qui ne sont pas susceptibles d'être complètement retenues dans le cache de second niveau. Pour les assocations de classes en cache, où il y a une extrêmement forte probabilité que l'élément soit en cache, désactivez explicitement le chargement par jointures ouvertes en utilisant <literal>outer-join=\"false\"</literal>. Lorsqu'un chargement par jointure ouverte est approprié pour un cas d'utilisation particulier, utilisez une requête avec un <literal>left join fetch</literal>."
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr "Utilisez le pattern <emphasis>d'une ouverture de session dans une vue</emphasis>, ou une <emphasis>phase d'assemblage</emphasis> disciplinée pour éviter des problèmes avec des données non rapatriées."
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr "Hibernate libère les développeurs de l'écriture fastidieuse des <emphasis>objets de transfert de données (NdT : Data Transfer Objects)</emphasis> (DTO). Dans une architecture EJB traditionnelle, les DTOs ont deux buts : premièrement, ils contournent le problème des \"entity bean\" qui ne sont pas sérialisables ; deuxièmement, ils définissent implicitement une phase d'assemblage où toutes les données utilisées par la vue sont rapatriées et organisées dans les DTOs avant de retourner sous le contrôle de la couche de présentation. Hibernate élimine le premier but. Pourtant, vous aurez encore besoin d'une phase d'assemblage (pensez vos méthodes métier comme ayant un contrat strict avec la couche de présentation à propos de quelles données sont disponibles dans les objets détachés) à moins que vous soyez préparés à garder le contexte de persistance (la session) ouvert à travers tout le processus de rendu de la vue."
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr "Pensez à abstraite votre logique métier d'Hibernate."
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr "Cachez le mécanisme d'accès aux données (Hibernate) derrière une interface. Combinez les patterns <emphasis>DAO</emphasis> et <emphasis>Thread Local Session</emphasis>. Vous pouvez même avoir quelques classes persistées par du JDBC pur, associées à Hibernate via un <literal>UserType</literal> (ce conseil est valable pour des applications de taille respectables ; il n'est pas valable pour une application avec cinq tables)."
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr "N'utilisez pas d'associations de mapping exotiques."
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr "De bons cas d'utilisation pour de vraies associations plusieurs-vers-plusieurs sont rares. La plupart du temps vous avez besoin d'informations additionnelles stockées dans la table d'association. Dans ce cas, il est préférable d'utiliser deux associations un-vers-plusieurs vers une classe de liaisons intermédiaire. En fait, nous pensons que la plupart des associations sont de type un-vers-plusieurs ou plusieurs-vers-un, vous devez être très attentifs lorsque vous utilisez autre chose et vous demander si c'est vraiment nécessaire."
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr "Préférez les associations bidirectionnelles."
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr "Les associations unidirectionnelles sont plus difficiles à questionner. Dans une grande application, la plupart des associations devraient être navigables dans les deux directions dans les requêtes."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1287 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr "Mapping des collections"
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr "Collections persistantes"
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr "Hibernate requiert que les champs contenant des collections persistantes soient déclarés comme des types d'interface, par exemple :"
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ "\n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr "L'interface réelle devrait être <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> ou ... n'importe quoi d'autre ! (Où \"n'importe quoi d'autre\" signifie que vous devrez écrire une implémentation de <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr "Notez comment nous avons initialisé les variables d'instance avec une instance de <literal>HashSet</literal>. C'est le meilleur moyen pour initialiser les collections d'instances nouvellement créées (non persistantes). Quand nous fabriquons l'instance persistante - en appelant <literal>persist()</literal>, par exemple - Hibernate remplacera réellement le <literal>HashSet</literal> avec une instance d'une implémentation propre à Hibernate de <literal>Set</literal>. Prenez garde aux erreurs :"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Ok, la collection kittens est un Set\n"
+ "(HashSet) cat.getKittens(); // Erreur !]]>"
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr "Les collections persistantes injectées par Hibernate se comportent de la même manière que <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> ou <literal>ArrayList</literal>, selon le type de l'interface."
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr "Les instances des collections ont le comportement habituel des types des valeurs. Elles sont automatiquement persistées quand elles sont référencées par un objet persistant et automatiquement effacées quand elles sont déréférencées. Si une collection est passée d'un objet persistant à un autre, ses éléments pourraient être déplacés d'une table à une autre. Deux entités ne peuvent pas partager une référence vers une même instance d'une collection. Dû au modèle relationnel sous-jacent, les propriétés contenant des collections ne supportent pas la sémantique de la valeur null ; Hibernate ne distingue pas une référence vers une collection nulle d'une collection vide."
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr "Vous ne devriez pas vous préoccuper trop de ça. Utilisez les collections persistantes de la même manière que vous utilisez des collections Java ordinaires. Assurez-vous de comprendre la sémantique des associations bidirectionnelles (traitée plus loin)."
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr "Mapper une collection"
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr "L'élément de mapping d'Hibernate utilisé pour mapper une collection dépend du type de l'interface. Par exemple, un élément <literal><set></literal> est utilisé pour mapper des propriétés de type <literal>Set</literal>."
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr "À part <literal><set></literal>, il y aussi les éléments de mapping <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> et <literal><primitive-array></literal>. L'élément <literal><map></literal> est représentatif :"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map\n"
+ " name=\"nomDePropriete\"\n"
+ " table=\"nom_de_table\"\n"
+ " schema=\"nom_du_schema\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan\"\n"
+ " sort=\"unsorted|natural|ClasseDeComparateur\"\n"
+ " order-by=\"nom_de_column asc|desc\"\n"
+ " where=\"condition sql where quelcconque\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|NomDeClasse\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"nom-d-element|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr "<literal>name</literal> : le nom de la propriété contenant la collection"
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr "<literal>table</literal> (optionnel - par défaut = nom de la propriété) : le nom de la table de la collection (non utilisé pour les associations one-to-many)"
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr "<literal>schema</literal> (optionnel) : le nom du schéma pour surcharger le schéma déclaré dans l'élément racine"
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr "<literal>lazy</literal> (optionnel - par défaut = <literal>true</literal>) : peut être utilisé pour désactiver l'initialisation tardive et spécifier que l'association est toujours rapportée, ou pour activer la récupération extra-paresseuse (NdT : extra-lazy) où la plupart des opérations n'initialisent pas la collection (approprié pour de très grosses collections)"
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr "<literal>inverse</literal> (optionnel - par défaut = <literal>false</literal>) : définit cette collection comme l'extrêmité \"inverse\" de l'association bidirectionnelle"
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr "<literal>cascade</literal> (optionnel - par défaut = <literal>none</literal>) : active les opérations de cascade vers les entités filles"
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr "<literal>sort</literal> (optionnel) : spécifie une collection triée via un ordre de tri <literal>naturel</literal>, ou via une classe comparateur donnée (implémentant Comparator)"
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr "<literal>order-by</literal> (optionnel, seulement à partir du JDK1.4) : spécifie une colonne de table (ou des colonnes) qui définit l'ordre d'itération de <literal>Map</literal>, <literal>Set</literal> ou Bag, avec en option <literal>asc</literal> ou <literal>desc</literal>"
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr "<literal>where</literal> (optionnel) : spécifie une condition SQL arbitraire <literal>WHERE</literal> à utiliser au chargement ou à la suppression d'une collection (utile si la collection ne doit contenir qu'un sous ensemble des données disponibles)"
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr "<literal>fetch</literal> (optionnel, par défaut = <literal>select</literal>) : à choisir entre récupération par jointures externes, récupération par selects séquentiels, et récupération par sous-selects séquentiels"
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr "<literal>batch-size</literal> (optionnel, par défaut = <literal>1</literal>) : une taille de batch (batch size) utilisée pour charger plusieurs instances de cette collection en initialisation tardive"
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr "<literal>access</literal> (optionnel - par défaut = <literal>property</literal>) : La stratégie qu'Hibernate doit utiliser pour accéder à la valeur de la propriété"
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr "<literal>optimistic-lock</literal> (optionnel - par défaut = <literal>true</literal>) : spécifie que changer l'état de la collection entraîne l'incrémentation de la version appartenant à l'entité (Pour une association un vers plusieurs, il est souvent raisonnable de désactiver ce paramètre)"
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr "<literal>mutable</literal> (optionnel - par défaut = <literal>true</literal>) : une valeur à <literal>false</literal> spécifie que les éléments de la collection ne changent jamais (une optimisation mineure dans certains cas)"
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr "Les clefs étrangères d'une collection"
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr "Les instances d'une collection sont distinguées dans la base par la clef étrangère de l'entité qui possède la collection. Cette clef étrangère est référencée comme la(es) <emphasis>colonne(s) de la clef de la collection</emphasis> de la table de la collection. La colonne de la clef de la collection est mappée par l'élément <literal><key></literal>."
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr "Il peut y avoir une contrainte de nullité sur la colonne de la clef étrangère. Pour les associations unidirectionnelles un vers plusieurs, la colonne de la clef étrangère peut être nulle par défaut, donc vous pourriez avoir besoin de spécifier <literal>not-null=\"true\"</literal>."
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr "La contraite de la clef étrangère peut utiliser <literal>ON DELETE CASCADE</literal>."
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr "Voir le chapitre précédent pour une définition complète de l'élément <literal><key></literal>."
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr "Les éléments d'une collection"
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr "Les collections peuvent contenir la plupart des autres types Hibernate, dont tous les types basiques, les types utilisateur, les composants, et bien sûr, les références vers d'autres entités. C'est une distinction importante : un objet dans une collection pourrait être géré avec une sémantique de \"valeur\" (sa durée de vie dépend complètement du propriétaire de la collection) ou il pourrait avoir une référence vers une autre entité, avec sa propre durée de vie. Dans le dernier cas, seul le \"lien\" entre les 2 objets est considéré être l'état retenu par la collection."
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr "Le type contenu est référencé comme le <emphasis>type de l'élément de la collection</emphasis>. Les éléments de la collections sont mappés par <literal><element></literal> ou <literal><composite-element></literal>, ou dans le cas des références d'entité, avec <literal><one-to-many></literal> ou <literal><many-to-many></literal>. Les deux premiers mappent des éléments avec un sémantique de valeur, les deux suivants sont utilisés pour mapper des associations d'entité."
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr "Collections indexées"
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr "Tous les mappings de collection, exceptés ceux avec les sémantiques d'ensemble (NdT : set) et de sac (NdT : bag), ont besoin d'une <emphasis>colonne d'index</emphasis> dans la table de la collection - une colonne qui mappe un index de tableau, ou un index de <literal>List</literal>, ou une clef de <literal>Map</literal>. L'index d'une <literal>Map</literal> peut être n'importe quel type basique, mappé avec <literal><map-key></literal>, ça peut être une référence d'entité mappée avec <literal><map-key-many-to-many></literal>, ou ça peut être un type composé, mappé avec <literal><composite-map-key></literal>. L'index d'un tableau ou d'une liste est toujours de type <literal>integer</literal> et est mappé en utilisant l'élément <literal><list-index></literal>. Les colonnes mappées contiennent des entiers séquentiels (numérotés à partir de zéro par défaut)."
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index\n"
+ " column=\"nom_de_colonne\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>nom_de_colonne</literal> (requis) : le nom de la colonne contenant les valeurs de l'index de la collection </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optionnel, par défaut = <literal>0</literal>) : la valeur de la colonne de l'index qui correspond au premier élément de la liste ou du tableau </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key\n"
+ " column=\"nom_de_colonne\"\n"
+ " formula=\"n'importe quelle expression SQL\"\n"
+ " type=\"nom_du_type\"\n"
+ " node=\"@nom-d-attribut\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optionnel) : le nom de la colonne contenant les valeurs de l'index de la collection </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optionnel) : une formule SQL utilisée pour évaluer la clef de la map </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguis): le type des clefs de la map </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"nom_de_colonne\"\n"
+ " formula=\"n'importe quelle expression SQL\"\n"
+ " class=\"NomDeClasse\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optionnel) : le nom de la colonne de la clef étrangère pour les valeurs de l'index de la collection </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optionnel) : une formulre SQL utilisée pour évaluer la clef étrangère de la clef de la map </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (requis): la classe de l'entité utilisée comme clef de la map </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr "Si votre table n'a pas de colonne d'index, et que vous souhaitez tout de même utiliser <literal>List</literal> comme type de propriété, vous devriez mapper la propriété comme un <emphasis><bag></emphasis> Hibernate. Un sac (NdT : bag) ne garde pas son ordre quand il est récupéré de la base de données, mais il peut être optionnellement trié ou ordonné."
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr "Il y a pas mal de variétés de mappings qui peuvent être générés pour les collections, couvrant beaucoup des modèles relationnels communs. Nous vous suggérons d'expérimenter avec l'outil de génération de schéma pour avoir une idée de comment traduire les différentes déclarations de mapping vers des table de la base de données."
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr "Collections de valeurs et associations plusieurs-vers-plusieurs"
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr "N'importe quelle collection de valeurs ou association plusieurs-vers-plusieurs requiert une <emphasis>table de collection</emphasis> avec une(des) colonne(s) de clef étrangère, une(des) <emphasis>colonne(s) d'élément de la collection</emphasis> ou des colonnes et possiblement une(des) colonne(s) d'index."
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr "Pour une collection de valeurs, nous utilisons la balise <literal><element></literal>."
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"nom_de_colonne\"\n"
+ " formula=\"n'importe quelle expression SQL\"\n"
+ " type=\"nomDeType\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"nom-d-element\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optionnel) : le nom de la colonne contenant les valeurs de l'élément de la collection </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optionnel) : une formule SQL utilisée pour évaluer l'élément </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (requis) : le type de l'élément de la collection </para> </callout> </calloutlist> </programlistingco> <para> Une <emphasis>association plusieurs-vers-plusieurs</emphasis> est spécifiée en utilisant l'élément <literal><many-to-many></literal>. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <a!
rea id=\"manytomany7\" coords=\"8 60\"/> <area id=\"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"nom_de_colonne\"\n"
+ " formula=\"n'importe quelle expression SQL\"\n"
+ " class=\"NomDeClasse\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"NomDEntite\"\n"
+ " property-ref=\"nomDeProprieteDeLaClasseAssociee\"\n"
+ " node=\"nom-d-element\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optionnel) : le nom de la colonne de la clef étrangère de l'élément </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optionnel) : une formule SQL utilisée pour évaluer la valeur de la clef étrangère de l'élément </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (requis) : le nom de la classe associée </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optionnel - par défaut <literal>join</literal>) : active les récupérations par jointures externes ou par selects séquentiels pour cette association. C'est un cas spécial ; pour une récupération complète sans attente (dans un seul <literal>SELECT</literal>) d'une entité et de ses relations plusieurs-vers-plusieurs vers d'autres entités, vous devriez activer la récupération <literal!
>join</literal> non seulement sur la collection elle-même, mais aussi avec cet attribut sur l'élément imbriqué <literal><many-to-many></literal>. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optionnel) : activer la génération DDL d'une contrainte d'unicité pour la colonne de la clef étrangère. Ça rend la pluralité de l'association effectivement un-vers-plusieurs. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optionnel - par défaut <literal>exception</literal>) : spécifie comment les clefs étrangères qui référencent la lignes manquantes seront gérées : <literal>ignore</literal> traitera une ligne manquante comme une association nulle. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optionnel) : le nom de l'entité de la classe associée, comme une alternative à <literal>class</literal> </para> </callout> <callout arear!
efs=\"manytomany8\"> <para> <literal>property-ref</literal> (optionnel
) : le nom d'une propriété de la classe associée qui est jointe à cette clef étrangère. Si non spécifiée, la clef primaire de la classe associée est utilisée. </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr "Quelques exemples, d'abord, un ensemble de chaînes de caractères :"
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr "Un bag contenant des entiers (avec un ordre d'itération déterminé par l'attribut <literal>order-by</literal>) :"
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr ""
+ "<![CDATA[<bag name=\"sizes\"\n"
+ " table=\"item_sizes\"\n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr "Un tableau d'entités - dans ce cas, une association plusieurs-vers-plusieurs :"
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr ""
+ "<![CDATA[<array name=\"addresses\"\n"
+ " table=\"PersonAddress\"\n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr "Une map de chaînes de caractères vers des dates :"
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"holidays\"\n"
+ " table=\"holidays\"\n"
+ " schema=\"dbo\"\n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr "Une liste de composants (discute dans le prochain chapitre) :"
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr ""
+ "<![CDATA[<list name=\"carComponents\"\n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr "Association un-vers-plusieurs"
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr "Une <emphasis>association un vers plusieurs</emphasis> lie les tables de deux classes par une clef étrangère, sans l'intervention d'une table de collection. Ce mapping perd certaines sémantiques des collections Java normales :"
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr "Une instance de la classe de l'entité contenue ne peut pas appartenir à plus d'une instance de la collection"
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr "Une instance de la classe de l'entité contenue ne peut pas apparaître plus plus d'une valeur d'index de la collection"
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr "Une association de <literal>Product</literal> vers <literal>Part</literal> requiert l'existence d'une clef étrangère et possiblement une colonne d'index pour la table <literal>Part</literal>. Une balise <literal><one-to-many></literal> indique que c'est une association un vers plusieurs."
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr ""
+ "<![CDATA[<one-to-many\n"
+ " class=\"NomDeClasse\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"NomDEntite\"\n"
+ " node=\"nom-d-element\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr "<literal>class</literal> (requis) : le nom de la classe associée"
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>not-found</literal> (optionnel - par défaut <literal>exception</literal>) : spécifie comment les identifiants cachés qui référencent des lignes manquantes seront gérés : <literal>ignore</literal> traitera une ligne manquante comme une association nulle"
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr "<literal>entity-name</literal> (optionnel) : le nom de l'entité de la classe associée, comme une alternative à <literal>class</literal>."
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr "Notez que l'élément <literal><one-to-many></literal> n'a pas besoin de déclarer de colonnes. Il n'est pas non plus nécessaire de spécifier le nom de la table nulle part."
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr "<emphasis>Note très importante :</emphasis> si la colonne de la clef d'une association <literal><one-to-many></literal> est déclarée <literal>NOT NULL</literal>, vous devez déclarer le mapping de <literal><key></literal> avec <literal>not-null=\"true\"</literal> ou <emphasis>utiliser une association bidirectionnelle</emphasis> avec le mapping de la collection marqué <literal>inverse=\"true\"</literal>. Voir la discussion sur les associations bidirectionnelles plus tard dans ce chapitre."
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr "Cet exemple montre une map d'entités <literal>Part</literal> par nom (où <literal>partName</literal> est une propriété persistante de <literal>Part</literal>). Notez l'utilisation d'un index basé sur une formule."
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr "Mappings de collection avancés"
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr "Collections triées"
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr "Hibernate supporte des collections implémentant <literal>java.util.SortedMap</literal> et <literal>java.util.SortedSet</literal>. Vous devez spécifier un comparateur dans le fichier de mapping :"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\"\n"
+ " table=\"person_aliases\"\n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr "Les valeurs permises pour l'attribut <literal>sort</literal> sont <literal>unsorted</literal>, <literal>natural</literal> et le nom d'une classe implémentant <literal>java.util.Comparator</literal>."
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr "Les collections triées se comportent réellement comme <literal>java.util.TreeSet</literal> ou <literal>java.util.TreeMap</literal>."
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr "Si vous voulez que la base de données elle-même ordonne les éléments de la collection, utilisez l'attribut <literal>order-by</literal> des mappings <literal>set</literal>, <literal>bag</literal> ou <literal>map</literal>. Cette solution est seulement disponible à partir du JDK 1.4 (c'est implémenté en utilisant <literal>LinkedHashSet</literal> ou <literal>LinkedHashMap</literal>). Ceci exécute le tri dans la requête SQL, pas en mémoire."
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr "Notez que la valeur de l'attribut <literal>order-by</literal> est un ordre SQL, pas un ordre HQL !"
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr "Les associations peuvent même être triées sur des critères arbitraires à l'exécution en utilisant un <literal>filter()</literal> de collection."
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr "Associations bidirectionnelles"
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr "Une <emphasis>association bidirectionnelle</emphasis> permet une navigation à partir de la \"fin\" de l'association. Deux sortes d'associations bidirectionnelles sont supportées :"
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr "un-vers-plusieurs (NdT : one-to-many)"
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr "ensemble ou sac à une extrémité, une seule valeur à l'autre"
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr "plusieurs-vers-plusieurs (NdT : many-to-many)"
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr "ensemble ou sac aux deux extrémités"
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr "Vous pouvez spécifier une association plusieurs-vers-plusieurs bidirectionnelle simplement en mappant deux associations plusieurs-vers-plusieurs vers la même table de base de données et en déclarant une extrémité comme <emphasis>inverse</emphasis> (celle de votre choix, mais ça ne peut pas être une collection indexée)."
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr "Voici un exemple d'association bidirectionnelle plusieurs-vers-plusieurs ; chaque catégorie peut avoir plusieurs objets et chaque objet peut être dans plusieurs catégories :"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>
+\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr "Les changements faits uniquement sur l'extréminté inverse de l'association <emphasis>ne sont pas</emphasis> persistés. Ceci signifie qu'Hibernate a deux représentations en mémoire pour chaque association bidirectionnelles, un lien de A vers B et un autre de B vers A. C'est plus facile à comprendre si vous pensez au modèle objet de Java et comment nous créons une relation plusieurs-vers-plusieurs en Java :"
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // La catégorie est maintenant \"au courant\" de la relation\n"
+ "item.getCategories().add(category); // L'objet est maintenant \"au courant\" de la relation\n"
+ "\n"
+ "session.persist(item); // La relation ne sera pas sauvegardée !\n"
+ "session.persist(category); // La relation sera sauvegardée]]>"
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr "La partie non-inverse est utilisée pour sauvegarder la représentation en mémoire dans la base de données."
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr "Vous pouvez définir une association un-vers-plusieurs bidirectionnelle en mappant une association un-vers-plusieurs vers la(es) même(s) colonne(s) de table qu'une association plusieurs-vers-un et en déclarant l'extrémité pluri-valuée <literal>inverse=\"true\"</literal>."
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\"\n"
+ " class=\"Parent\"\n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr "Mapper une extrémité d'une association avec <literal>inverse=\"true\"</literal> n'affecte pas l'opération de cascades, ce sont des concepts orthogonaux !"
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr "Associations bidirectionnelles avec des collections indexées"
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr "Une association bidirectionnelle où une extrémité est représentée comme une <literal><list></literal> ou une <literal><map></literal> requiert une considération spéciale. Si il y a une propriété de la classe enfant qui mappe la colonne de l'index, pas de problème, nous pouvons continuer à utiliser <literal>inverse=\"true\"</literal> sur le mapping de la collection :"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\"\n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\"\n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\"\n"
+ " class=\"Parent\"\n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr "Mais, si il n'y a pas de telle prorpriété sur la classe enfant, nous ne pouvons pas penser à l'association comme vraiment bidirectionnelle (il y a des informations disponibles à une extrémité de l'association qui ne sont pas disponibles à l'autre extrémité). Dans ce cas, nous ne pouvons pas mapper la collection <literal>inverse=\"true\"</literal>. À la place, nous pourrions utiliser le mapping suivant :"
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\"\n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\"\n"
+ " class=\"Parent\"\n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr "Notez que dans ce mapping, l'extrémité de l'association contenant la collection est responsable des mises à jour de la clef étrangère. À faire : cela entraîne-t-il réellement des expressions updates inutiles ?"
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr "Associations ternaires"
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr "Il y a trois approches possibles pour mapper une association ternaire. L'une est d'utiliser une <literal>Map</literal> avec une association en tant qu'index :"
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr "Une seconde approche est simplement de remodeler l'association comme une classe d'entité. C'est l'approche la plus commune."
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr "Une alternative finale est d'utiliser des éléments composites, dont nous discuterons plus tard."
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr "Utiliser un <literal><idbag></literal>"
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr "Si vous embrassez pleinement notre vue que les clefs composées sont une mauvaise chose et que des entités devraient avoir des identifiants artificiels (des clefs subrogées), alors vous pourriez trouver un peu curieux que les associations plusieurs-vers-plusieurs et les collections de valeurs que nous avons montré jusqu'ici mappent toutes des tables avec des clefs composées ! Maintenant, ce point est assez discutable ; une table d'association pure ne semble pas beaucoup bénéficier d'une clef subrogée (bien qu'une collection de valeur composées le <emphasis>pourrait</emphasis>). Néanmoins, Hibernate fournit une foncionnalité qui vous permet de mapper des associations plusieurs-vers-plusieurs et des collections de valeurs vers une table avec une clef subrogée."
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr "L'élément <literal><idbag></literal> vous laisse mapper une <literal>List</literal> (ou une <literal>Collection</literal>) avec une sémantique de sac."
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr "Comme vous pouvez voir, un <literal><idbag></literal> a un généréteur d'id artificiel, comme une classe d'entité ! Une clef subrogée différente est assignée à chaque ligne de la collection. Cependant, Hibernate ne fournit pas de mécanisme pour découvrir la valeur d'une clef subrogée d'une ligne particulière."
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr "Notez que les performances de la mise à jour d'un <literal><idbag></literal> sont <emphasis>bien</emphasis> meilleures qu'un <literal><bag></literal> ordinaire ! Hibernate peut localiser des lignes individuelles efficacement et les mettre à jour ou les effacer individuellement, comme une liste, une map ou un ensemble."
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr "Dans l'implémentation actuelle, la stratégie de la génération de l'identifiant <literal>native</literal> n'est pas supportée pour les identifiants de collection <literal><idbag></literal>."
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr "Exemples de collections"
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr "Les sections précédentes sont assez confuses. Donc prenons un exemple. Cette classe :"
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr "a une collection d'instances de <literal>Child</literal>. Si chaque enfant a au plus un parent, le mapping le plus naturel est une association un-vers-plusieurs :"
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr "Ceci mappe les définitions de tables suivantes :"
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr "Si le parent est <emphasis>requis</emphasis>, utilisez une association un-vers-plusieurs unidirectionnelle :"
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr "Notez la contrainte <literal>NOT NULL</literal> :"
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr "Alternativement, si vous insistez absolument pour que cette association soit unidirectionnelle, vous pouvez déclarer la contrainte <literal>NOT NULL</literal> sur le mapping <literal><key></literal> :"
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr "D'un autre côté, si un enfant pouvait avoir plusieurs parent, une association plusieurs-vers-plusieurs est plus appropriée :"
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr "Définitions des tables :"
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr "Pour plus d'exemples et une revue complète du mapping de la relation parent/enfant, voir see <xref linkend=\"example-parentchild\"/>."
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr "Des mappings d'association plus exotiques sont possibles, nous cataloguerons toutes les possibilités dans le prochain chapitre."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,532 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr "Mapping de composants"
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr "La notion de <emphasis>composants</emphasis> est réutilisé dans différents contextes, avec différents objectifs, à travers Hibernate."
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr "Objects dépendants"
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr "Le composant est un objet inclu dans un autre qui est sauvegardé comme une valeur, et non pas comme une entité. Le composant fait référence à la notion (au sens objet) de composition (et non pas de composant au sens d'architecture de composants). Par exemple on pourrait modélisé l'objet personne de cette façon:"
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr "Maintenant <literal>Name</literal> peut-être sauvegardé comme un composant de <literal>Person</literal>. Remarquer que <literal>Name</literal> définit des methodes d'accès et de modification pour ses propriétés persistantes, mais il n'a pas besoin des interfaces ou des propriétés d'identification ( par exemple getId() ) qui sont propres aux entités."
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr "Nous serions alors amené à mapper ce composant de cette façon:"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:38
+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 "La table person aurai les colonnes <literal>pid</literal>, <literal>birthday</literal>, <literal>initial</literal>, <literal>first</literal> and <literal>last</literal>."
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr "Comme tous les types valeurs, les composants ne supportent pas les références partagés. En d'autres mots, deux instances de person peuvent avoir un même nom, mais ces noms sont indépendants, ils peuvent être identiques si on les compare par valeur mais ils représentent deux objets distincts en mémoire. La notion de nullité pour un composant est <emphasis>ad hoc</emphasis>. Quand il recharge l'objet qui contient le composant, Hibernate supposera que si tous les champs du composants sont nuls alors le composant sera positionné à la valeur null. Ce choix programmatif devrait être satisfaisant dans la plupart des cas."
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr "Les propriétés d'un composant peuvent être de tous les types qu'Hibernate supporte habituellement (collections, many-to-one associations, autres composants, etc). Les composants inclus ne doivent <emphasis>pas</emphasis> être vus comme quelque chose d'exotique. Hibernate a été conçu pour supporter un modèle objet très granulaire."
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "Le <literal><component></literal> peut inclure dans la liste de ses propriétés une référence au <literal><parent></literal> conteneur."
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- référence arrière à Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr "Collection d'objets dépendants"
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr "Les collections d'objets dépendants sont supportés (exemple: un tableau de type <literal>Name</literal>). Déclarer la collection de composants en remplaçant le tag <literal><element></literal> par le tag <literal><composite-element></literal>."
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr "Remarque: Si vous définissez un <literal>Set</literal> d'élément composite, il est très important d'implémenter la méthode <literal>equals()</literal> et <literal>hashCode()</literal> correctement."
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr "Les élements composite peuvent aussi contenir des composants mais pas des collections. Si votre élément composite contient aussi des composants, utilisez l'élément <literal><nested-composite-element></literal> . Une collections de composants qui ccontiennent eux-mêmes des composants est un cas très exotique. A ce stade demandez-vous si une association un-à -plusieurs ne serait pas plus approprié. Essayez de re remodeler votre élément composite comme une entité ( Dans ce cas même si le modèle Java est le même la logique de persitence et de relation sont tout de même différentes)"
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr "Remarque, le mapping d'éléments composites ne supporte pas la nullité des propriétés lorsqu'on utilise un <literal><set></literal>. Hibernate lorsqu'il supprime un objet utilise chaque colonne pour identifier un objet (on ne peut pas utiliser des clés primaires distinctes dans une table d'éléments composites), ce qui n'est pas possible avec des valeurs nulles. Vous devez donc choisir d'interdire la nullité des propriétés d'un élément composite ou choisir un autre type de collection comme : <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> ou <literal><idbag></literal>."
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 "Un cas particulier d'élément composite est un élément composite qui inclut un élément <literal><many-to-one></literal>. Un mapping comme celui-ci vous permet d'associer les colonnes d'une table d'association plusieurs à plusieurs (many-to-many) à la classse de l'élément composite. L'exemple suivant est une association plusieurs à plusieurs de <literal>Order</literal> à <literal>Item</literal> à <literal>purchaseDate</literal>, <literal>price</literal> et <literal>quantity</literal> sont des propriétés de l'association."
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr "Bien sûr, il ne peut pas y avoir de référence à l'achat (purchase) depuis l'article (item), pour pouvoir naviguer de façon bidirectionnelle dans l'association. N'oubliez pas que les composants sont de type valeurs et n'autorise pas les références partagées."
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr "Même les associations ternaires ou quaternaires sont possibles:"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr "Les éléments composites peuvent apparaître dans les requêtes en utilisant la même syntaxe que associations"
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr "Utiliser les composants comme index de map"
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr "l'élément <literal><composite-map-key></literal> vous permet d'utiliser une classe de composant comme indice de <literal>Map</literal>. Assurez-vous d'avoir surdéfini <literal>hashCode()</literal> et <literal>equals()</literal> dans la classe du composant."
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr "Utiliser un composant comme identifiant"
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr "Vous pouvez utiliser un composant comme identifiant d'une entité. Mais pour cela la classe du composant doit respecter certaines règles."
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr "Elle doit implémenter <literal>java.io.Serializable</literal>."
+
+#: index.docbook:170
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr "Elle doit redéfinir <literal>equals()</literal> et <literal>hashCode()</literal>, de façon cohérente avec le fait qu'elle définit une clé composite dans la base de données."
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr "Remarque: avec hibernate3, la seconde règle n'est plus absolument necessaire mais faîtes le quand même."
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr "Vous ne pouvez pas utiliser de <literal>IdentifierGenerator</literal> pour générer une clé composite, l'application devra définir elle même ses propres identifiants."
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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 "Utiliser l'élément <literal><composite-id></literal> (en incluant l'élément <literal><key-property></literal>) à la place de l'habituel déclaration <literal><id></literal>. Par exemple la classe <literal>OrderLine</literal> qui dépend de la clé primaire (composite) de <literal>Order</literal>."
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr "Maintenant toutes clés étrangères référençant la table <literal>OrderLine</literal> devra aussi être composite. Vous devez en tenir compte lorsque vous écrivez vos mapping d'association pour les autres classes. Une association à <literal>OrderLine</literal> devrait être mappé de la façon suivante :"
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr "(Remarque: l'élément <literal><column></literal> est une alternative à l'attribut <literal>column</literal> que l'on utilise partout.)"
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr "Une association <literal>plusieurs-à -plusieurs</literal> (many-to-many) à <literal>OrderLine</literal> utilisera aussi une clé étrangère composite:"
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr "La collection des <literal>OrderLine</literal>s dans <literal>Order</literal> utilisera:"
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr "(L'élément <literal><one-to-many></literal>, comme d'habitude, ne déclare pas de colonne.)"
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr "Si <literal>OrderLine</literal> lui-même possède une collection, celle-ci aura aussi une clé composite étrangère."
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr "Composant Dynamique"
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr "Vous pouvez même mapper une propriété de type <literal>Map</literal>:"
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\"/>\n"
+ " <property name=\"bar\" column=\"BAR\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr "La sémantique de l'association à un <literal><dynamic-component></literal> est identique à celle que l'on utilise pour les composants. L'avantage de ce type de mapping est qu'il pemet de déterminer les véritables propriétés du bean au moment su déploiement en éditant simplement le document de mapping. La manipulation du document de mapping pendant l'execution de l'application est aussi possible en utilisant un parser DOM. Il ya même mieux, vous pouvez accéder (et changer) le metamodel de configuration d'hibernate en utilisant l'objet <literal>Configuration</literal>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1595 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr "Configuration"
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr "Parce qu'Hibernate est conçu pour fonctionner dans différents environnements, il existe beaucoup de paramètres de configuration. Heureusement, la plupart ont des valeurs par défaut appropriées et la distribution d'Hibernate contient un exemple de fichier <literal>hibernate.properties</literal> dans le répertoire <literal>etc/</literal> qui montre les différentes options. Vous n'avez qu'à placer ce fichier dans votre classpath et à l'adapter."
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr "Configuration par programmation"
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr "Une instance de <literal>org.hibernate.cfg.Configuration</literal> représente un ensemble de mappings des classes Java d'une application vers la base de données SQL. La <literal>Configuration</literal> est utilisée pour construire un objet (immuable) <literal>SessionFactory</literal>. Les mappings sont constitués d'un ensemble de fichiers de mapping XML."
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr "Vous pouvez obtenir une instance de <literal>Configuration</literal> en l'instanciant directement et en spécifiant la liste des documents XML de mapping. Si les fichiers de mapping sont dans le classpath, vous pouvez le faire à l'aide de la méthode <literal>addResource()</literal> :"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr "Une alternative (parfois meilleure) est de spécifier les classes mappées et de laisser Hibernate trouver les documents de mapping pour vous :"
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr "Hibernate va rechercher les fichiers de mappings <literal>/org/hibernate/auction/Item.hbm.xml</literal> et <literal>/org/hibernate/auction/Bid.hbm.xml</literal> dans le classpath. Cette approche élimine les noms de fichiers en dur."
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr "Une <literal>Configuration</literal> vous permet également de préciser des propriétés de configuration :"
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr "Ce n'est pas le seul moyen de passer des propriétés de configuration à Hibernate. Les différentes options sont :"
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr "Passer une instance de <literal>java.util.Properties</literal> Ã <literal>Configuration.setProperties()</literal>."
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr "Placer <literal>hibernate.properties</literal> dans un répertoire racine du classpath"
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr "Positionner les propriétés <literal>System</literal> en utilisant <literal>java -Dproperty=value</literal>."
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr "Inclure des éléments <literal><property></literal> dans le fichier <literal>hibernate.cfg.xml</literal> (voir plus loin)."
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr "L'utilisation d'<literal>hibernate.properties</literal> est l'approche la plus simple si vous voulez démarrer rapidement"
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr "La <literal>Configuration</literal> est un objet de démarrage qui sera supprimé une fois qu'une <literal>SessionFactory</literal> aura été créée."
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr "Obtenir une SessionFactory"
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr "Une fois que tous les mappings ont été parsés par la <literal>Configuration</literal>, l'application doit obtenir une fabrique d'instances de <literal>Session</literal>. Cette fabrique sera partagée entre tous les threads de l'application :"
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr "Hibernate permet à votre application d'instancier plus d'une <literal>SessionFactory</literal>. Cela est pratique lorsque vous utilisez plus d'une base de données."
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr "Connexions JDBC"
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr "Habituellement, vous voulez que la <literal>SessionFactory</literal> crée les connexions JDBC et les mette dans un pool pour vous. Si vous suivez cette approche, ouvrir une <literal>Session</literal> est aussi simple que :"
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr "Dès que vous ferez quelquechose qui requiert un accès à la base de données, une connexion JDBC sera récupérée dans le pool."
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr "Pour faire cela, il faut passer les propriétés de la connexion JDBC à Hibernate. Tous les noms des propriétés Hibernate et leur signification sont définies dans la classe <literal>org.hibernate.cfg.Environment</literal>. Nous allons maintenant décrire les paramètres de configuration des connexions JDBC les plus importants."
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr "Hibernate obtiendra des connexions (et les mettra dans un pool) en utilisant <literal>java.sql.DriverManager</literal> si vous positionnez les paramètres de la manière suivante :"
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr "Propriétés JDBC d'Hibernate"
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr "Nom de la propriété"
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr "Fonction"
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr "Classe du driver jdbc"
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr "URL jdbc"
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:179
+msgid "database user"
+msgstr "utilisateur de la base de données"
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:187
+msgid "database user password"
+msgstr "mot de passe de la base de données"
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr "hibernate.connection.pool_size"
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr "nombre maximum de connexions dans le pool"
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr "L'algorithme natif de pool de connexions d'Hibernate est plutôt rudimentaire. Il a été fait dans le but de vous aider à démarrer et <emphasis>n'est pas prévu pour un système en production</emphasis> ou même pour un test de peformance. Utilisez plutôt un pool tiers pour de meilleures performances et une meilleure stabilité : pour cela, remplacez la propriété <literal>hibernate.connection.pool_size</literal> avec les propriétés spécifique au pool de connexions que vous avez choisi. Cela désactivera le pool de connexions interne d'Hibernate. Vous pouvez par exemple utiliser C3P0."
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr "C3P0 est un pool de connexions JDBC open source distribué avec Hibernate dans le répertoire <literal>lib</literal>. Hibernate utilisera son provider <literal>C3P0ConnectionProvider</literal> pour le pool de connexions si vous positionnez les propriétés <literal>hibernate.c3p0.*</literal>. Si vous voulez utiliser Proxool, référez vous au groupe de propriétés d'<literal>hibernate.properties</literal> correspondant et regardez sur le site web d'Hibernate pour plus d'informations."
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr "Voici un exemple de fichier <literal>hibernate.properties</literal> pour C3P0:"
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statement=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr "Dans le cadre de l'utilisation au sein d'un serveur d'applications, vous devriez quasiment toujours configurer Hibernate pour qu'il obtienne ses connexions de la <literal>DataSource</literal> du serveur d'application enregistrée dans le JNDI. Pour cela vous devrez définir au moins une des propriétés suivantes :"
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr "Propriété d'une Datasource Hibernate"
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr "hibernate.connection.datasource"
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr "Nom JNDI de la datasource"
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr "hibernate.jndi.url"
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr "<emphasis>URL du fournisseur JNDI</emphasis> (optionnelle)"
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr "hibernate.jndi.class"
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr "<emphasis>Classe de l'<literal>InitialContextFactory</literal> du JNDI</emphasis> (optionnelle)"
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr "<emphasis>utilisateur de la base de données</emphasis> (optionnelle)"
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr "<emphasis>mot de passe de la base de données</emphasis> (optionnelle)"
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr "Voici un exemple de fichier <literal>hibernate.properties</literal> pour l'utilisation d'une datasource JNDI fournie par un serveur d'applications :"
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr "Les connexions JDBC obtenues à partir d'une datasource JNDI participeront automatiquement aux transactions gérées par le conteneur du serveur d'applications."
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr "Des propriétés supplémentaires de connexion peuvent être passées en préfixant le nom de la propriété par \"<literal>hibernate.connnection</literal>\". Par exemple, vous pouvez spécifier un jeu de caractères en utilisant <literal>hibernate.connection.charSet</literal>."
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr "Vous pouvez fournir votre propre stratégie d'obtention des connexions JDBC en implémentant l'interface <literal>org.hibernate.connection.ConnectionProvider</literal>. Vous pouvez sélectionner une implémentation spécifique en positionnant <literal>hibernate.connection.provider_class</literal>."
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr "Propriétés de configuration optionnelles"
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr "Il y a un certain nombre d'autres propriétés qui contrôlent le fonctionnement d'Hibernate à l'exécution. Toutes sont optionnelles et ont comme valeurs par défaut des valeurs \"raisonnables\" pour un fonctionnement nominal."
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr "<emphasis>Attention : Certaines de ces propriétés sont uniquement de niveau System.</emphasis> Les propriétés de niveau System ne peuvent être positionnées que via la ligne de commande (<literal>java -Dproperty=value</literal>) ou être définies dans <literal>hibernate.properties</literal>. Elle <emphasis>ne peuvent pas</emphasis> l'être via une des autres techniques décrites ci-dessus."
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr "Propriétés de configuration d'Hibernate"
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr "Le nom de la classe du <literal>Dialect</literal> Hibernate. qui permet à Hibernate de générer du SQL optimisé pour une base de données relationnelle particulière."
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>nom.complet.de.ma.classe.de.Dialect</literal>"
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr "hibernate.show_sql"
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr "Ecrit toutes les requêtes SQL sur la console. Il s'agit d'une alternative au positionnement de la catégorie de log <literal>org.hibernate.SQL</literal> au niveau <literal>debug</literal>."
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr "hibernate.format_sql"
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr "Formate et indente le sql dans la console et dans le log"
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr "hibernate.default_schema"
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr "Positionne dans le SQL généré un schéma/tablespace par défaut pour les noms de table ne l'ayant pas surchargé."
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>MON_SCHEMA</literal>"
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr "hibernate.default_catalog"
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr "Qualifie les noms de tables non qualifiées avec ce catalogue dans le SQL généré."
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>CATALOG_NAME</literal>"
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr "hibernate.session_factory_name"
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr "La <literal>SessionFactory</literal> sera automatiquement liée à ce nom dans le JNDI après sa création."
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>jndi/nom/hierarchique</literal>"
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr "hibernate.max_fetch_depth"
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr "Définit la profondeur maximale d'un arbre de chargement par jointures ouvertes pour les associations à cardinalité unitaire (un-à -un, plusieurs-à -un). Un <literal>0</literal> désactive le chargement par jointure ouverte."
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> valeurs recommandées entre <literal>0</literal> et <literal>3</literal>"
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr "hibernate.default_batch_fetch_size"
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr "Définit une taille par défaut pour le chargement par lot des associations"
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> Valeurs recommandées : <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr "hibernate.default_entity_mode"
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr "Définit un mode de représentation par défaut des entités pour toutes les sessions ouvertes depuis cette <literal>SessionFactory</literal>"
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr "hibernate.order_updates"
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr "Force Hibernate à trier les updates SQL par la valeur de la clé primaire des éléments qui sont mis à jour. Cela permet de limiter les deadlocks de transaction dans les systèmes hautement concurents."
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr "hibernate.generate_statistics"
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr "Si activé, Hibernate va collecter des statistiques utiles pour le réglage des performances."
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr "hibernate.use_identifer_rollback"
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr "Si activé, les propriétés correspondant à l'identifiant des objets vont être remises aux valeurs par défaut lorsque les objets seront supprimés."
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr "hibernate.use_sql_comments"
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr "Si activé, Hibernate va générer des commentaires à l'intérieur des requêtes SQL pour faciliter le debogage., par défaut à <literal>false</literal>."
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr "Propriétés Hibernate liées à JDBC et aux connexions"
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr "hibernate.jdbc.fetch_size"
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr "Une valeur non nulle détermine la taille de chargement des statements JDBC (appelle <literal>Statement.setFetchSize()</literal>)."
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr "hibernate.jdbc.batch_size"
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr "Une valeur non nulle active l'utilisation par Hibernate des mises à jour par batch de JDBC2."
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> les valeurs recommandées entre <literal>5</literal> et <literal>30</literal>"
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr "hibernate.jdbc.batch_versioned_data"
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr "Paramétrez cette propriété à <literal>true</literal> si votre pilote JDBC retourne des row counts corrects depuis <literal>executeBatch()</literal> (il est souvent approprié d'activer cette option). Hibernate utilisera alors le \"batched DML\" pour versionner automatiquement les données. Par défaut = <literal>false</literal>."
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr "hibernate.jdbc.factory_class"
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr "Sélectionne un <literal>Batcher</literal> personnalisé. La plupart des applications n'auront pas besoin de cette propriété de configuration"
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr "hibernate.jdbc.use_scrollable_resultset"
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr "Active l'utilisation par Hibernate des resultsets scrollables de JDBC2. Cette propriété est seulement nécessaire lorsque l'on utilise une connexion JDBC fournie par l'utilisateur. Autrement, Hibernate utilise les métadonnées de la connexion."
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr "hibernate.jdbc.use_streams_for_binary"
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr "Utilise des flux lorsque l'on écrit/lit des types <literal>binary</literal> ou <literal>serializable</literal> vers et à partir de JDBC (propriété de niveau système)."
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr "hibernate.jdbc.use_get_generated_keys"
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr "Active l'utilisation de <literal>PreparedStatement.getGeneratedKeys()</literal> de JDBC3 pour récupérer nativement les clés générées après insertion. Nécessite un pilote JDBC3+, le mettre à false si votre pilote a des problèmes avec les générateurs d'identifiant Hibernate. Par défaut, essaie de déterminer les possibilités du pilote en utilisant les meta données de connexion."
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr "hibernate.connection.provider_class"
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr "Le nom de la classe d'un <literal>ConnectionProvider</literal> personnalisé qui fournit des connexions JDBC à Hibernate"
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr "hibernate.connection.isolation"
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr "Définit le niveau d'isolation des transactions JDBC. Regardez <literal>java.sql.Connection</literal> pour connaître le sens des différentes valeurs mais notez également que la plupart des bases de données ne supportent pas tous les niveaux d'isolation."
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>1, 2, 4, 8</literal>"
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr "hibernate.connection.autocommit"
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr "Active le mode de commit automatique (autocommit) pour les connexions JDBC du pool (non recommandé)."
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr "hibernate.connection.release_mode"
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr "Spécifie à quel moment Hibernate doit relacher les connexion JDBC. Par défaut une connexion JDBC est conservée jusqu'à ce que la session soit explicitement fermée ou déconnectée. Pour une source de données JTA d'un serveur d'application, vous devriez utiliser <literal>after_statement</literal> pour libérer les connexions de manière plus agressive après chaque appel JDBC. Pour une connexion non JTA, il est souvent préférable de libérer la connexion à la fin de chaque transaction en utilisant <literal>after_transaction</literal>. <literal>auto</literal> choisira <literal>after_statement</literal> pour des transactions JTA et CMT et <literal>after_transaction</literal> pour des transactions JDBC."
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>on_close</literal> (default) | <literal>after_transaction</literal> | <literal>after_statement</literal> | <literal>auto</literal>"
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr "hibernate.connection.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr "Passe la propriété JDBC<literal>propertyName</literal> à <literal>DriverManager.getConnection()</literal>."
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr "hibernate.jndi.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr "Passe la propriété <literal>propertyName</literal> à l'<literal>InitialContextFactory</literal> de JNDI."
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr "Propriétés du Cache d'Hibernate"
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr "Nom de la propriété"
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr "Le nom de classe d'un <literal>CacheProvider</literal> spécifique."
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>nom.de.classe.du.CacheProvider</literal>"
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr "hibernate.cache.use_minimal_puts"
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr "Optimise le cache de second niveau en minimisant les écritures, au prix de plus de lectures. Ce paramètre est surtout utile pour les caches en cluster et est activé par défaut dans hibernate3 pour les implémentations de cache en cluster."
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr "Activer le cache de requête, les requêtes individuelles doivent tout de même être déclarées comme pouvant être mise en cache."
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr "Peut être utilisé pour désactiver complètement le cache de second niveau qui est activé par défaut pour les classes qui spécifient un élément <literal><cache></literal> dans leur mapping."
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr "Le nom de classe d'une interface <literal>QueryCacheFactory</literal> , par défaut = built-in <literal>StandardQueryCacheFactory</literal>."
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>nom.de.la.classe.de.QueryCacheFactory</literal>"
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr "hibernate.cache.region_prefix"
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr "Un préfixe à utiliser pour le nom des régions du cache de second niveau."
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>prefix</literal>"
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr "hibernate.cache.use_structured_entries"
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr "Force Hibernate à stocker les données dans le cache de second niveau dans un format plus adapté à la visualisation par un humain."
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr "Nom de la propriété"
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr "Le nom de classe d'une <literal>TransactionFactory</literal> qui sera utilisée par l'API <literal>Transaction</literal> d'Hibernate (la valeur par défaut est <literal>JDBCTransactionFactory</literal>)."
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>nom.de.classe.d.une.TransactionFactory</literal>"
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr "jta.UserTransaction"
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr "Le nom JNDI utilisé par la <literal>JTATransactionFactory</literal> pour obtenir la <literal>UserTransaction</literal> JTA du serveur d'applications."
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/nom/compose</literal>"
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr "Le nom de la classe du <literal>TransactionManagerLookup</literal> - requis lorsque le cache de niveau JVM est activé ou lorsque l'on utilise un générateur hilo dans un environnement JTA."
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>nom.de.classe.du.TransactionManagerLookup</literal>"
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr "hibernate.transaction.flush_before_completion"
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr "Si activé, la session sera automatiquement vidée durant la phase qui précède la fin de la transaction (before completion). La gestion automatique de contexte fourni par Hibernate est recommandée, voir <xref linkend=\"architecture-current-session\"/>."
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr "Si activé, la session sera automatiquement fermé pendant la phase qui suit la fin de la transaction (after completion). La gestion automatique de contexte fourni par Hibernate est recommandée, voir"
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr "Nom de la propriété"
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr "Fournit une stratégie particulière pour contextualiser la <literal>Session</literal> courante. Voir <xref linkend=\"architecture-current-session\"/> pour plus d'informations sur les stratégies fournies."
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>custom.Class</literal>"
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr "hibernate.query.factory_class"
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr "Choisi l'implémentation du parseur de requête"
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> ou <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr "hibernate.query.substitutions"
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr "Lien entre les tokens de requêtes Hibernate et les tokens SQL (les tokens peuvent être des fonctions ou des noms littéraux par exemple)."
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr "hibernate.hbm2ddl.auto"
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr "Valide ou exporte automatiquement le schéma DDL vers la base de données lorsque la <literal>SessionFactory</literal> est créée. La valeur <literal>create-drop</literal> permet de supprimer le schéma de base de données lorsque la <literal>SessionFactory</literal> est fermée explicitement."
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr "hibernate.cglib.use_reflection_optimizer"
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr "Active l'utilisation de CGLIB à la place de la réflexion à l'exécution (Propriété de niveau système). La réflexion peut parfois être utile pour résoudre des problèmes. Notez qu'Hibernate a tout de même toujours besoin de CGLIB même si l'optimiseur est désactivé. Cette optimisation ne peut être définie que dans le fichier <literal>hibernate.cfg.xml</literal>."
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr "<emphasis role=\"strong\">ex.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr "Vous devriez toujours positionner la propriété <literal>hibernate.dialect</literal> à la sous-classe de <literal>org.hibernate.dialect.Dialect</literal> appropriée à votre base de données. Si vous spécifiez un dialecte, Hibernate utilisera des valeurs adaptées pour certaines autres propriétés listées ci-dessus, vous évitant l'effort de le faire à la main."
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr "Dialectes SQL d'Hibernate (<literal>hibernate.dialect</literal>)"
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr "SGBD"
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr "Dialecte"
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr "<entry>DB2</entry>"
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr "org.hibernate.dialect.DB2Dialect"
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr "DB2 AS/400"
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr "org.hibernate.dialect.DB2400Dialect"
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr "DB2 OS390"
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr "org.hibernate.dialect.DB2390Dialect"
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr "PostgreSQL"
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr "org.hibernate.dialect.PostgreSQLDialect"
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr "MySQL"
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr "org.hibernate.dialect.MySQLDialect"
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr "MySQL with InnoDB"
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr "org.hibernate.dialect.MySQLInnoDBDialect"
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr "MySQL with MyISAM"
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr "org.hibernate.dialect.MySQLMyISAMDialect"
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr "Oracle (any version)"
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr "org.hibernate.dialect.OracleDialect"
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr "Oracle 9i/10g"
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr "org.hibernate.dialect.Oracle9Dialect"
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr "Sybase"
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr "org.hibernate.dialect.SybaseDialect"
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr "Sybase Anywhere"
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr "org.hibernate.dialect.SybaseAnywhereDialect"
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr "Microsoft SQL Server"
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr "org.hibernate.dialect.SQLServerDialect"
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr "SAP DB"
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr "org.hibernate.dialect.SAPDBDialect"
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr "Informix"
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr "org.hibernate.dialect.InformixDialect"
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr "HypersonicSQL"
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr "org.hibernate.dialect.HSQLDialect"
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr "Ingres"
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr "org.hibernate.dialect.IngresDialect"
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr "Progress"
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr "org.hibernate.dialect.ProgressDialect"
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr "Mckoi SQL"
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr "org.hibernate.dialect.MckoiDialect"
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr "Interbase"
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr "org.hibernate.dialect.InterbaseDialect"
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr "Pointbase"
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr "org.hibernate.dialect.PointbaseDialect"
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr "FrontBase"
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr "org.hibernate.dialect.FrontbaseDialect"
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr "Firebird"
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr "org.hibernate.dialect.FirebirdDialect"
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr "Chargement par Jointure Ouverte"
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr "Si votre base de données supporte les outer joins de type ANSI, Oracle ou Sybase, <emphasis>le chargement par jointure ouverte</emphasis> devrait améliorer les performances en limitant le nombre d'aller-retour avec la base de données (la base de données effectuant donc potentiellement plus de travail). Le chargement par jointure ouverte permet à un graphe entier d'objets connectés par une relation plusieurs-à -un, un-à -plusieurs ou un-à -un d'être chargé en un seul <literal>SELECT</literal> SQL."
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr "Le chargement par jointure ouverte peut être désactiver <emphasis>globalement</emphasis> en mettant la propriété <literal>hibernate.max_fetch_depth</literal> à <literal>0</literal>. Une valeur de <literal>1</literal> ou plus active le chargement par jointure ouverte pour les associatiosn un-à -un et plusieurs-à -un qui ont été mappée avec <literal>fetch=\"join\"</literal>."
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr "Reportez vous à <xref linkend=\"performance-fetching\"/> pour plus d'information."
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "Flux binaires"
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr "Oracle limite la taille d'un tableau de <literal>byte</literal> qui peuvent être passées à et vers son pilote JDBC. Si vous souhaitez utiliser des instances larges de type <literal>binary</literal> ou <literal>serializable</literal>, vous devez activer la propriété <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>C'est une fonctionalité de niveau système uniquement.</emphasis>"
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr "Cache de second niveau et cache de requêtes"
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr "Les propriétés préfixées par <literal>hibernate.cache</literal> vous permettent d'utiliser un système de cache de second niveau. Ce cache peut avoir une portée dans le processus ou même être utilisable dans un système distribué. Référez vous au chapitre <xref linkend=\"performance-cache\"/> pour plus de détails."
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr "Substitution dans le langage de requêtage"
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr "Vous pouvez définir de nouveaux tokens dans les requêtes Hibernate en utilisant la propriété <literal>hibernate.query.substitutions</literal>. Par exemple :"
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr "hibernate.query.substitutions vrai=1, faux=0"
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr "remplacerait les tokens <literal>vrai</literal> et <literal>faux</literal> par des entiers dans le SQL généré."
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr "hibernate.query.substitutions toLowercase=LOWER"
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr "permettrait de renommer la fonction SQL <literal>LOWER</literal> en <literal>toLowercase</literal>"
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr "Statistiques Hibernate"
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr "Si vous activez <literal>hibernate.generate_statistics</literal>, Hibernate va fournir un certains nombre de métriques utiles pour régler les performances d'une application qui tourne via <literal>SessionFactory.getStatistics()</literal>. Hibernate peut aussi être configuré pour exposer ces statistiques via JMX. Lisez les Javadoc des interfaces dans le package <literal>org.hibernate.stats</literal> pour plus d'informations."
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr "Tracer"
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr "Hibernate trace divers évènements en utilisant Apache commons-logging."
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr "Le service commons-logging délèguera directement à Apache Log4j (si vous incluez <literal>log4j.jar</literal> dans votre classpath) ou le système de trace du JDK 1.4 (si vous tournez sous le JDK 1.4 et supérieur). Vous pouvez télécharger Log4j à partir de <literal>http://jakarta.apache.org</literal>. Pour utiliser Log4j, vous devrez placer dans votre classpath un fichier <literal>log4j.properties</literal>. Un exemple de fichier est distribué avec Hibernate dans le répertoire <literal>src/</literal>."
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr "Nous vous recommandons fortement de vous familiariser avec les messages des traces d'Hibernate. Beaucoup de soins a été apporté pour donner le plus de détails possible sans les rendre illisibles. C'est un outil essentiel en cas de soucis. Les catégories de trace les plus intéressantes sont les suivantes :"
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr "Catégories de trace d'Hibernate"
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr "Catégorie"
+
+#: index.docbook:1219
+msgid "Category"
+msgstr "Fonction"
+
+#: index.docbook:1220
+msgid "Function"
+msgstr "org.hibernate.SQL"
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr "Trace toutes les requêts SQL de type DML (gestion des données) qui sont exécutées"
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr "org.hibernate.type"
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr "Trace tous les paramètres JDBC"
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr "org.hibernate.tool.hbm2ddl"
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr "Trace toutes les requêts SQL de type DDL (gestion de la structure de la base) qui sont exécutées"
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr "org.hibernate.pretty"
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr "Trace l'état de toutes les entités (20 entités maximum) qui sont associées avec la session hibernate au moment du flush"
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr "org.hibernate.cache"
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr "Trace toute l'activité du cache de second niveau"
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr "org.hibernate.transaction"
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr "Trace toute l'activité relative aux transactions"
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr "org.hibernate.jdbc"
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr "Trace toute acquisition de ressource JDBC"
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr "org.hibernate.hql.ast.AST"
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr "Trace l'arbre syntaxique des requêtes HQL et SQL durant l'analyse syntaxique des requêtes"
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr "org.hibernate.secure"
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr "Trace toutes les demandes d'autorisation JAAS"
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr "org.hibernate"
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr "Trace tout (beaucoupe d'informations, mais très utile pour résoudre les problèmes)."
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr "Lorsque vous développez des applications avec Hibernate, vous devriez quasiment toujours travailler avec le niveau <literal>debug</literal> activé pour la catégorie <literal>org.hibernate.SQL</literal>, ou sinon avec la propriété <literal>hibernate.show_sql</literal> activée."
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr "Implémenter une <literal>NamingStrategy</literal>"
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr "L'interface <literal>org.hibernate.cfg.NamingStrategy</literal> vous permet de spécifier une \"stratégie de nommage\" des objets et éléments de la base de données."
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr "Vous pouvez fournir des règles pour automatiquement générer les identifiants de base de données à partir des identifiants Java, ou transformer une colonne ou table \"logique\" donnée dans le fichier de mapping en une colonne ou table \"physique\". Cette fonctionnalité aide à réduire la verbosité de documents de mapping, en éliminant le bruit répétitif (les préfixes <literal>TBL_</literal> par exemple). La stratégie par défaut utilisée par Hibernate est minimale."
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr "Vous pouvez définir une stratégie différente en appelant <literal>Configuration.setNamingStrategy()</literal> avant d'ajouter des mappings :"
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr "<literal>net.sf.hibernate.cfg.ImprovedNamingStrategy</literal> est une stratégie fournie qui peut être utile comme point de départ de quelques applications."
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr "Fichier de configuration XML"
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr "Une approche alternative est de spécifier toute la configuration dans un fichier nommé <literal>hibernate.cfg.xml</literal>. Ce fichier peut être utilisé à la place du fichier <literal>hibernate.properties</literal>, voire même peut servir à surcharger les propriétés si les deux fichiers sont présents."
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr "Le fichier de configuration XML doit par défaut se placer à la racine du <literal>CLASSPATH</literal>. En voici un exemple :"
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr "Commme vous pouvez le voir, l'avantage de cette approche est l'externalisation des noms des fichiers de mapping de la configuration. Le fichier <literal>hibernate.cfg.xml</literal> est également plus pratique quand on commence à régler le cache d'Hibernate. Notez que vous pouvez choisir entre utiliser <literal>hibernate.properties</literal> ou <literal>hibernate.cfg.xml</literal>, les deux sont équivalents, sauf en ce qui concerne les bénéfices de l'utilisation de la syntaxe XML mentionnés ci-dessus."
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr "Avec la configuration XML, démarrer Hibernate devient donc aussi simple que ceci :"
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr "Intégration à un serveur d'application J2EE"
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr "Hibernate possède les points suivants d'intégration à l'infrastructure J2EE :"
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr "<emphasis>Source de données gérée par le conteneur</emphasis> : Hibernate peut utiliser des connexions JDBC gérées par le conteneur et fournie par l'intermédiaire de JNDI. Souvent, un <literal>TransactionManager</literal> compatible JTA et un <literal>ResourceManager</literal> s'occupent de la gestion des transactions (CMT). Ils sont particulièrement prévus pour pouvoir gérer des transactions distribuées sur plusieurs sources de données. Vous pouvez bien sûr également définir vos limites de transaction dans votre programme (BMT) ou vous pouvez sinon aussi utiliser l'API optionnelle <literal>Transaction</literal> d'Hibernate qui vous garantira la portabilité de votre code entre plusieurs serveurs d'application."
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr "<emphasis>Association JNDI automatique</emphasis>: Hibernate peut associer sa <literal>SessionFactory</literal> à JNDI après le démarrage."
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr "<emphasis>Association de la Session à JTA:</emphasis> La <literal>Session</literal> Hibernate peut être associée automatiquement à une transaction JTA si vous utilisez les EJBs. Vous avez juste à récupérer la <literal>SessionFactory</literal> depuis JNDI et à récupérer la <literal>Session</literal> courante. Hibernate s'occupe de vider et fermer la <literal>Session</literal> lorsque le transaction JTA se termine. La démarcation des transactions se fait de manière déclarative dans les descripteurs de déploiement."
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr "<emphasis>Déploiement JMX :</emphasis>Si vous avez un serveur d'application compatible JMX (JBoss AS par exemple), vous pouvez choisir de déployer Hibernate en temps que MBean géré par le serveur. Cela vous évite de coder la ligne de démarrage qui permet de construire la <literal>SessionFactory</literal> depuis la <literal>Configuration</literal>. Le conteneur va démarrer votre <literal>HibernateService</literal>, et va idéalement s'occuper des dépendances entre les services (la source de données doit être disponible avant qu'Hibernate ne démarre, etc)."
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr "En fonction de votre environnement, vous devrez peut être mettre l'option de configuration <literal>hibernate.connection.aggressive_release</literal> à vrai si le serveur d'application affiche des exceptions de type \"connection containment\"."
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr "Configuration de la stratégie transactionnelle"
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr "L'API de la <literal>Session</literal> Hibernate est indépendante de tout système de démarcation des transactions qui peut être présent dans votre architecture. Si vous laissez Hibernate utiliser l'API JDBC directement via un pool de connexion, vous devrez commencer et terminer vos transactions en utilisant l'API JDBC. Si votre application tourne à l'intérieur d'un serveur d'application J2EE, vous voudrez peut être utiliser les transactions gérées par les beans (BMT) et appeller l'API JTA et <literal>UserTransaction</literal> lorsque cela est nécessaire."
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr "Pour conserver votre code portable entre ces deux environnements (et d'autres éventuels) nous vous recommandons d'utiliser l'API optionnelle <literal>Transaction</literal> d'Hibernate, qui va encapsuler et masquer le système de transaction sous-jacent. Pour cela, vous devez préciser une classe de fabrique d'instances de <literal>Transaction</literal> en positionnant la propriété <literal>hibernate.transaction.factory_class</literal>."
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr "Il existe trois choix standards (fournis) :"
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr "net.sf.hibernate.transaction.JDBCTransactionFactory"
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr "délègue aux transactions de la base de données (JDBC). Valeur par défaut."
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr "org.hibernate.transaction.JTATransactionFactory"
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr "délègue à CMT si une transaction existante est sous ce contexte (ex: méthode d'un EJB session), sinon une nouvelle transaction est entamée et une transaction gérée par le bean est utilisée."
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr "org.hibernate.transaction.CMTTransactionFactory"
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr "délègue à aux transactions JTA gérées par le conteneur"
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr "Vous pouvez également définir votre propre stratégie transactionnelle (pour un service de transaction CORBA par exemple)."
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr "Certaines fonctionnalités d'Hibernate (i.e. le cache de second niveau, l'association automatique des Session à JTA, etc.) nécessitent l'accès au <literal>TransactionManager</literal> JTA dans un environnement \"managé\". Dans un serveur d'application, vous devez indiquer comment Hibernate peut obtenir une référence vers le <literal>TransactionManager</literal>, car J2EE ne fournit pas un seul mécanisme standard."
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr "TransactionManagers JTA"
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr "Fabrique de Transaction"
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr "Serveur d'application"
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr "org.hibernate.transaction.JBossTransactionManagerLookup"
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr "JBoss"
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr "Weblogic"
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr "WebSphere"
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr "WebSphere 6"
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr "org.hibernate.transaction.OrionTransactionManagerLookup"
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr "Orion"
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr "org.hibernate.transaction.ResinTransactionManagerLookup"
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr "Resin"
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr "org.hibernate.transaction.JOTMTransactionManagerLookup"
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr "JOTM"
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr "org.hibernate.transaction.JOnASTransactionManagerLookup"
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr "JOnAS"
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr "org.hibernate.transaction.JRun4TransactionManagerLookup"
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr "JRun4"
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr "org.hibernate.transaction.BESTransactionManagerLookup"
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr "Borland ES"
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr "<literal>SessionFactory</literal> associée au JNDI"
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr "Une <literal>SessionFactory</literal> Hibernate associée au JNDI peut simplifier l'accès à la fabrique et donc la création de nouvelles <literal>Session</literal>s. Notez que cela n'est pas lié avec les <literal>Datasource</literal> associées au JNDI, elles utilisent juste le même registre."
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr "Si vous désirez associer la <literal>SessionFactory</literal> à un nom JNDI, spécifiez un nom (ex. <literal>java:hibernate/SessionFactory</literal>) en utilisant la propriété <literal>hibernate.session_factory_name</literal>. Si cette propriété est omise, la <literal>SessionFactory</literal> ne sera pas associée au JNDI (c'est particulièrement pratique dans les environnements ayant une implémentation de JNDI en lecture seule, comme c'est le cas pour Tomcat)."
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr "Lorsqu'il associe la <literal>SessionFactory</literal> au JNDI, Hibernate utilisera les valeurs de <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> pour instancier un contexte d'initialisation. S'ils ne sont pas spécifiés, l'<literal>InitialContext</literal> par défaut sera utilisé."
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr "Hibernate va automatiquement placer la <literal>SessionFactory</literal> dans JNDI après avoir appelé <literal>cfg.buildSessionFactory()</literal>. Cela signifie que vous devez avoir cet appel dans un code de démarrage (ou dans une classe utilitaire) dans votre application sauf si vous utilisez le déploiement JMX avec le service <literal>HibernateService</literal> présenté plus tard dans ce document."
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr "Si vous utilisez <literal>SessionFactory</literal> JNDI, un EJB ou n'importe quelle autre classe peut obtenir la <literal>SessionFactory</literal> en utilisant un lookup JNDI."
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr "Nous recommandons que vous liiez la <literal>SessionFactory</literal> à JNDI dans les environnements managés et que vous utilisiez un singleton <literal>static</literal> si ce n'est pas le cas. Pour isoler votre application de ces détails, nous vous recommandons aussi de masquer le code de lookup actuel pour une <literal>SessionFactory</literal> dans une classe helper, comme <literal>HibernateUtil.getSessionFactory()</literal>. Notez qu'une telle classe est aussi un moyen efficace de démarrer Hibernate—voir chapitre 1."
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr "Association automatique de la Session à JTA"
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr "Le moyen le plus simple de gérer les <literal>Session</literal>s et transactions est la gestion automatique de session \"courante\" offerte par Hibernate. Voir détail à <xref linkend=\"architecture-current-session\"/>current sessions. En utilisant le contexte de session <literal>\"jta\"</literal> session context, s'il n'y a pas de <literal>Session</literal> associée à la transaction JTA courante, une session sera démarrée et associée à la transaction JTA courante la première fois que vous appelez <literal>sessionFactory.getCurrentSession()</literal>. Les <literal>Session</literal>s obtenue via <literal>getCurrentSession()</literal> dans une contexte <literal>\"jta\"</literal> seront automatiquement flushées avant la validation de la transaction, fermées une fois la transaction complétée, et libéreront les connexions JDBC de manière aggressive après chaque statement. Ceci permet aux <literal>Session</literal>s d'être gérées par le cycle de vie de !
la transaction JTA à la quelle est sont associées, laissant le code de l'utilisateur propre de ce type de gestion. Votre code peut soit utiliser JTA de manière programmatique via <literal>UserTransaction</literal>, ou (ce qui est recommandé pour la portabilité du code) utiliser l'API <literal>Transaction</literal> API pour marquer les limites. Si vous exécutez sous un conteneur EJB, la démarcation déclarative des transactions avec CMT est recommandée."
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr "Déploiement JMX"
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr "La ligne <literal>cfg.buildSessionFactory()</literal> doit toujours être exécutée quelque part pour avoir une <literal>SessionFactory</literal> dans JNDI. Vous pouvez faire cela dans un bloc d'initialisation <literal>static</literal> (comme celui qui se trouve dans la classe <literal>HibernateUtil</literal>) ou vous pouvez déployer Hibernate en temps que <emphasis>service managé</emphasis>."
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr "Hibernate est distribué avec <literal>org.hibernate.jmx.HibernateService</literal> pour le déploiement sur un serveur d'application avec le support de JMX comme JBoss AS. Le déploiement et la configuration sont spécifiques à chaque vendeur. Voici un fichier <literal>jboss-service.xml</literal> d'exemple pour JBoss 4.0.x:"
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr "Ce fichier est déployé dans un répertoire <literal>META-INF</literal> et est packagé dans un fichier JAR avec l'extension <literal>.sar</literal> (service archive). Vous devez également packager Hibernate, les librairies tierces requises, vos classes persistantes compilées et vos fichiers de mapping dans la même archive. Vos beans entreprise (souvent des EJBs session) peuvent rester dans leur propre fichier JAR mais vous pouvez inclure ce fichier JAR dans le jar principal du service pour avoir une seule unité déployable à chaud. Vous pouvez consulter la documentation de JBoss AS pour plus d'information sur les services JMX et le déploiement des EJBs."
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr ""
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,358 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr "Les intercepteurs et les événements"
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr "Il est souvent utile pour l'application de réagir à certains événements qui surviennent dans Hibernate. Cela autorise l'implémentation de certaines sortes de fonctionnalités génériques, et d'extensions de fonctionnalités d'Hibernate."
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr "Intercepteurs"
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr "L'interface <literal>Interceptor</literal> fournit des \"callbacks\" de la session vers l'application et permettent à l'application de consulter et/ou de manipuler des propriétés d'un objet persistant avant qu'il soit sauvegardé, mis à jour, supprimé ou chargé. Une utilisation possible de cette fonctionnalité est de tracer l'accès à l'information. Par exemple, l'<literal>Interceptor</literal> suivant positionne <literal>createTimestamp</literal> quand un <literal>Auditable</literal> est créé et met à jour la propriété <literal>lastUpdateTimestamp</literal> quand un <literal>Auditable</literal> est mis à jour."
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr "Vous pouvez soit implémenter <literal>Interceptor</literal> directement ou (mieux) étendre <literal>EmptyInterceptor</literal>."
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // ne fait rien\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void postFlush(Iterator entities) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates);\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr "L'intercepteur doit être spécifié quand une session est créée."
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr "Vous pouvez aussi mettre un intercepteur au niveau global, en utilisant l'objet <literal>Configuration</literal>. Dans ce cas, l'intercepteur doit être \"threadsafe\"."
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr "Système d'événements"
+
+#: index.docbook:61
+msgid "Event system"
+msgstr "Si vous devez réagir à des événements particuliers dans votre couche de persistance, vous pouvez aussi utiliser l'architecture d'<emphasis>événements</emphasis> d'Hibernate3. Le système d'événements peut être utilisé en supplément ou en remplacement des interceptors."
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr "Essentiellement toutes les méthodes de l'interface <literal>Session</literal> sont corrélées à un événement. Vous avez un <literal>LoadEvent</literal>, un <literal>FlushEvent</literal>, etc (consultez la DTD du fichier de configuration XML ou le paquet <literal>org.hibernate.event</literal> pour avoir la liste complète des types d'événement définis). Quand une requête est faite à partir d'une de ces méthodes, la <literal>Session</literal> Hibernate génère un événement approprié et le passe au listener configuré pour ce type. Par défaut, ces listeners implémentent le même traitement dans lequel ces méthodes aboutissent toujours. Cependant, vous êtes libre d'implémenter une version personnalisée d'une de ces interfaces de listener (c'est-à -dire, le <literal>LoadEvent</literal> est traité par l'implémentation de l'interface <literal>LoadEventListener</literal> déclarée), dans quel cas leur implémentation devrait être responsable du trai!
tement des requêtes <literal>load()</literal> faites par la <literal>Session</literal>."
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr "Les listeners devraient effectivement être considérés comme des singletons ; dans le sens où ils sont partagés entre des requêtes, et donc ne devraient pas sauvegarder des états de variables d'instance."
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr "Un listener personnalisé devrait implémenter l'interface appropriée pour l'événement qu'il veut traiter et/ou étendre une des classes de base (ou même l'événement prêt à l'emploi utilisé par Hibernate comme ceux déclarés non-finaux à cette intention). Les listeners personnalisés peuvent être soit inscrits par programmation à travers l'objet <literal>Configuration</literal>, ou spécifiés la configuration XML d'Hibernate (la configuration déclarative à travers le fichier de propriétés n'est pas supportée). Voici un exemple de listener personnalisé pour l'événement de chargement :"
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // C'est une simple méthode définie par l'interface LoadEventListener\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr "Vous avez aussi besoin d'une entrée de configuration disant à Hibernate d'utiliser ce listener en plus du listener par défaut :"
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr "Vous pouvez aussi l'inscrire par programmation :"
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr "Les listeners inscrits déclarativement ne peuvent pas partager d'instances. Si le même nom de classe est utilisée dans plusieurs éléments <literal><listener/></literal>, chaque référence sera une instance distincte de cette classe. Si vous avez besoin de la faculté de partager des instances de listener entre plusieurs types de listener, vous devez utiliser l'approche d'inscription par programmation."
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr "Pourquoi implémenter une interface et définir le type spécifique durant la configuration ? Une implémentation de listener pourrait implémenter plusieurs interfaces de listener d'événements. Avoir en plus le type défini durant l'inscription rend plus facile l'activation ou la désactivation pendant la configuration."
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr "Sécurité déclarative d'Hibernate"
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr "Généralement, la sécurité déclarative dans les applications Hibernate est gérée dans la couche de session. Maintenant, Hibernate3 permet à certaines actions d'être approuvées via JACC, et autorisées via JAAS. Cette fonctionnalité optionnelle est construite au dessus de l'architecture d'événements."
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr "D'abord, vous devez configurer les listeners d'événements appropriés pour permettre l'utilisation d'autorisations JAAS."
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr "Notez que <literal><listener type=\"...\" class=\"...\"/></literal> est juste un raccourci pour <literal><event type=\"...\"><listener class=\"...\"/></event></literal> quand il y a exactement un listener pour un type d'événement particulier."
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr "Ensuite, toujours dans <literal>hibernate.cfg.xml</literal>, lier les permissions aux rôles :"
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr "Les noms de rôle sont les rôles compris par votre fournisseur JAAC."
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1162 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr "Exemple : quelques mappings"
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr "Ce chapitre montre quelques mappings plus complexes."
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr "Employeur/Employé (Employer/Employee)"
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr "Le modèle suivant de relation entre <literal>Employer</literal> et <literal>Employee</literal> utilise une vraie classe entité (<literal>Employment</literal>) pour représenter l'association. On a fait cela parce qu'il peut y avoir plus d'une période d'emploi pour les deux mêmes parties. Des composants sont utilisés pour modéliser les valeurs monétaires et les noms des employés."
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr "Voici un document de mapping possible :"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr "Et voici le schéma des tables générées par <literal>SchemaExport</literal>."
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null,\n"
+ " name VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12),\n"
+ " employee_id BIGINT not null,\n"
+ " employer_id BIGINT not null,\n"
+ " end_date TIMESTAMP,\n"
+ " start_date TIMESTAMP,\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null,\n"
+ " firstName VARCHAR(255),\n"
+ " initial CHAR(1),\n"
+ " lastName VARCHAR(255),\n"
+ " taxfileNumber VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods\n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods\n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr "Auteur/Travail (Author/Work)"
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr "Soit le modèle de la relation entre <literal>Work</literal>, <literal>Author</literal> et <literal>Person</literal>. Nous représentons la relation entre <literal>Work</literal> et <literal>Author</literal> comme une association plusieurs-vers-plusieurs. Nous avons choisi de représenter la relation entre <literal>Author</literal> et <literal>Person</literal> comme une association un-vers-un. Une autre possibilité aurait été que <literal>Author</literal> hérite de <literal>Person</literal>."
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr "Le mapping suivant représente exactement ces relations :"
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr "Il y a quatre tables dans ce mapping. <literal>works</literal>, <literal>authors</literal> et <literal>persons</literal> qui contiennent respectivement les données de work, author et person. <literal>author_work</literal> est une table d'association qui lie authors à works. Voici le schéma de tables, généré par <literal>SchemaExport</literal>."
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " tempo FLOAT,\n"
+ " genre VARCHAR(255),\n"
+ " text INTEGER,\n"
+ " title VARCHAR(255),\n"
+ " type CHAR(1) not null,\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null,\n"
+ " work_id BIGINT not null,\n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " alias VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " name VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors\n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work\n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr "Client/Commande/Produit (Customer/Order/Product)"
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr "Imaginons maintenant le modèle de relation entre <literal>Customer</literal>, <literal>Order</literal>, <literal>LineItem</literal> et <literal>Product</literal>. Il y a une association un-vers-plusieurs entre <literal>Customer</literal> et <literal>Order</literal>, mais comment devrions nous représenter <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? J'ai choisi de mapper <literal>LineItem</literal> comme une classe d'association représentant l'association plusieurs-vers-plusieurs entre <literal>Order</literal> et <literal>Product</literal>. Dans Hibernate, on appelle cela un élément composite."
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr "Le document de mapping :"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> et <literal>products</literal> contiennent les données de customer, order, order line item et product. <literal>line_items</literal> est aussi la table d'association liant orders à products."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " name VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " customer_id BIGINT,\n"
+ " date TIMESTAMP,\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null,\n"
+ " order_id BIGINT not null,\n"
+ " product_id BIGINT,\n"
+ " quantity INTEGER,\n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity,\n"
+ " serialNumber VARCHAR(255),\n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders\n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr "Divers mappings d'exemple"
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr "Ces exemples sont tous pris de la suite de tests d'Hibernate. Vous en trouverez beaucoup d'autres. Regardez dans le dossier <literal>test</literal> de la distribution d'Hibernate."
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr "TODO: put words around this stuff"
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr "\"Typed\" one-to-one association"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\"\n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\"\n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\"\n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\"\n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\"\n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr "Exemple de clef composée"
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ "\n"
+ " <composite-id name=\"id\"\n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ "\n"
+ " <property name=\"orderDate\"\n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price)\n"
+ " from LineItem li, Product p\n"
+ " where li.productId = p.productId\n"
+ " and li.customerId = customerId\n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ "\n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"LineItem\">\n"
+ "\n"
+ " <composite-id name=\"id\"\n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ "\n"
+ " <property name=\"quantity\"/>\n"
+ "\n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ "\n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"description\"\n"
+ " not-null=\"true\"\n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ "\n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity)\n"
+ " from LineItem li\n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr "Many-to-many avec une clef composée partagée"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr "Contenu basé sur une discrimination"
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " column=\"person_id\"\n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ "\n"
+ " <discriminator\n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case\n"
+ " when title is not null then 'E'\n"
+ " when salesperson is not null then 'C'\n"
+ " else 'P'\n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ "\n"
+ " <subclass name=\"Employee\"\n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Customer\"\n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr "Associations sur des clefs alternées"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ "\n"
+ " <one-to-one name=\"address\"\n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ "\n"
+ " <set name=\"accounts\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ "\n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ "\n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ "\n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,350 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr "Exemple : Père/Fils"
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr "L'une des premières choses que les nouveaux utilisateurs essaient de faire avec Hibernate est de modéliser une relation père/fils. Il y a deux approches différentes pour cela. Pour un certain nombre de raisons, la méthode la plus courante, en particulier pour les nouveaux utilisateurs, est de modéliser les deux relations <literal>Père</literal> et <literal>Fils</literal> comme des classes entités liées par une association <literal><one-to-many></literal> du <literal>Père</literal> vers le <literal>Fils</literal> (l'autre approche est de déclarer le <literal>Fils</literal> comme un <literal><composite-element></literal>). Il est évident que le sens de l'association un vers plusieurs (dans Hibernate) est bien moins proche du sens habituel d'une relation père/fils que ne l'est celui d'un élément cmposite. Nous allons vous expliquer comment utiliser une association <emphasis>un vers plusieurs bidirectionnelle avec cascade</emphasis> afin de mo!
déliser efficacement et élégamment une relation père/fils, ce n'est vraiment pas difficile !"
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr "Une note à propos des collections"
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr "Les collections Hibernate sont considérées comme étant une partie logique de l'entité dans laquelle elles sont contenues ; jamais des entités qu'elle contient. C'est une distinction crutiale ! Les conséquences sont les suivantes :"
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr "Quand nous ajoutons / retirons un objet d'une collection, le numéro de version du propriétaire de la collection est incrémenté."
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr "Si un objet qui a été enlevé d'une collection est une instance de type valeur (ex : élément composite), cet objet cessera d'être persistant et son état sera complètement effacé de la base de données. Par ailleurs, ajouter une instance de type valeur dans une collection aura pour conséquence que son état sera immédiatement persistant."
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr "Si une entité est enlevée d'une collection (association un-vers-plusieurs ou plusieurs-vers-plusieurs), par défaut, elle ne sera pas effacée. Ce comportement est complètement logique - une modification de l'un des états internes d'une entité ne doit pas causer la disparition de l'entité associée ! De même, l'ajout d'une entité dans une collection n'engendre pas, par défaut, la persistance de cette entité."
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr "Le comportement par défaut est donc que l'ajout d'une entité dans une collection créé simplement le lien entre les deux entités, et qu'effacer une entité supprime ce lien. C'est le comportement le plus approprié dans la plupart des cas. Ce comportement n'est cependant pas approprié lorsque la vie du fils est liée au cycle de vie du père."
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr "un-vers-plusieurs bidirectionnel"
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr "Supposons que nous ayons une simple association <literal><one-to-many></literal> de <literal>Parent</literal> vers <literal>Child</literal>."
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>]]>"
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr "Si nous executions le code suivant"
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr "Hibernate exécuterait deux ordres SQL:"
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr "un <literal>INSERT</literal> pour créer l'enregistrement pour <literal>c</literal>"
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr "un <literal>UPDATE</literal> pour créer le lien de <literal>p</literal> vers <literal>c</literal>"
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr "Ceci est non seuleument inefficace, mais viole aussi toute contrainte <literal>NOT NULL</literal> sur la colonne <literal>parent_id</literal>. Nous pouvons réparer la contrainte de nullité en spécifiant <literal>not-null=\"true\"</literal> dans le mapping de la collection :"
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr "Cependant ce n'est pas la solution recommandée."
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr "La cause sous jacente à ce comportement est que le lien (la clé étrangère <literal>parent_id</literal>) de <literal>p</literal> vers <literal>c</literal> n'est pas considérée comme faisant partie de l'état de l'objet <literal>Child</literal> et n'est donc pas créé par l'<literal>INSERT</literal>. La solution est donc que ce lien fasse partie du mapping de <literal>Child</literal>."
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr "(Nous avons aussi besoin d'ajouter la propriété <literal>parent</literal> dans la classe <literal>Child</literal>)."
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr "Maintenant que l'état du lien est géré par l'entité <literal>Child</literal>, nous spécifions à la collection de ne pas mettre à jour le lien. Nous utilisons l'attribut <literal>inverse</literal>."
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr "Le code suivant serait utilisé pour ajouter un nouveau <literal>Child</literal>"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr "Maintenant, seul un <literal>INSERT</literal> SQL est nécessaire !"
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr "Pour alléger encore un peu les choses, nous devrions créer une méthode <literal>addChild()</literal> dans <literal>Parent</literal>."
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr "Le code d'ajout d'un <literal>Child</literal> serait alors"
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr "Cycle de vie en cascade"
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr "L'appel explicite de <literal>save()</literal> est un peu fastidieux. Nous pouvons simplifier cela en utilisant les cascades."
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr "Simplifie le code précédent en"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr "De la même manière, nous n'avons pas à itérer sur les fils lorsque nous sauvons ou effacons un <literal>Parent</literal>. Le code suivant efface <literal>p</literal> et tous ses fils de la base de données."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr "Par contre, ce code"
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr "n'effacera pas <literal>c</literal> de la base de données, il enlèvera seulement le lien vers <literal>p</literal> (et causera une violation de contrainte <literal>NOT NULL</literal>, dans ce cas). Vous devez explicitement utiliser <literal>delete()</literal> sur <literal>Child</literal>."
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr "Dans notre cas, un <literal>Child</literal> ne peut pas vraiment exister sans son père. Si nous effacons un <literal>Child</literal> de la collection, nous voulons vraiment qu'il soit effacé. Pour cela, nous devons utiliser <literal>cascade=\"all-delete-orphan\"</literal>."
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr "A noter : même si le mapping de la collection spécifie <literal>inverse=\"true\"</literal>, les cascades sont toujours assurées par l'itération sur les éléments de la collection. Donc, si vous avez besoin qu'un objet soit enregistré, effacé ou mis à jour par cascade, vous devez l'ajouter dans la colleciton. Il ne suffit pas d'appeler explicitement <literal>setParent()</literal>."
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr "Cascades et <literal>unsaved-value</literal>"
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr "Supposons que nous ayons chargé un <literal>Parent</literal> dans une <literal>Session</literal>, que nous l'ayons ensuite modifié et que voulions persiter ces modifications dans une nouvelle session en appelant <literal>update()</literal>. Le <literal>Parent</literal> contiendra une collection de fils et, puisque la cascade est activée, Hibernate a besoin de savoir quels fils viennent d'être instanciés et quels fils proviennent de la base de données. Supposons aussi que <literal>Parent</literal> et <literal>Child</literal> ont tous deux des identifiants du type <literal>Long</literal>. Hibernate utilisera la propriété de l'identifiant et la propriété de la version/horodatage pour déterminer quels fils sont nouveaux (vous pouvez aussi utiliser la propriété version ou timestamp, voir <xref linkend=\"manipulatingdata-updating-detached\"/>). <emphasis>Dans Hibernate3, il n'est plus nécessaire de spécifier une <literal>unsaved-value</literal> explicitemen!
t.</emphasis>"
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr "Le code suivant mettra à jour <literal>parent</literal> et <literal>child</literal> et insérera <literal>newChild</literal>."
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[//parent et child ont été chargés dans une session précédente\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr "Ceci est très bien pour des identifiants générés, mais qu'en est-il des identifiants assignés et des identifiants composés ? C'est plus difficile, puisqu'Hibernate ne peut pas utiliser la propriété de l'identifiant pour distinguer un objet nouvellement instancié (avec un identifiant assigné par l'utilisateur) d'un objet chargé dans une session précédente. Dans ce cas, Hibernate utilisera soit la propriété de version ou d'horodatage, soit effectuera vraiment une requête au cache de second niveau, soit, dans le pire des cas, à la base de données, pour voir si la ligne existe."
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr "Conclusion"
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr "Il y a quelques principes à maîtriser dans ce chapitre et tout cela peut paraître déroutant la première fois. Cependant, dans la pratique, tout fonctionne parfaitement. La plupart des applications Hibernate utilisent le pattern père / fils."
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr "Nous avons évoqué une alternative dans le premier paragraphe. Aucun des points traités précédemment n'existe dans le cas d'un mapping <literal><composite-element></literal> qui possède exactement la sémantique d'une relation père / fils. Malheureusement, il y a deux grandes limitations pour les classes éléments composites : les éléments composites ne peuvent contenir de collections, et ils ne peuvent être les fils d'entités autres que l'unique parent."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,840 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr "Exemple : application Weblog"
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr "Classes persistantes"
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr "Les classes persistantes representent un weblog, et un article posté dans un weblog. Il seront modélisés comme une relation père/fils standard, mais nous allons utiliser un \"bag\" trié au lieu d'un set."
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr "Mappings Hibernate"
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr "Le mapping XML doit maintenant être relativement simple à vos yeux."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr "Code Hibernate"
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr "La classe suivante montre quelques utilisations que nous pouvons faire de ces classes."
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ "\n"
+ " private SessionFactory _sessions;\n"
+ "\n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ "\n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ "\n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ "\n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ "\n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ "\n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ "\n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " item.setText(text);\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ "\n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ "\n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ "\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,192 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr "Filtrer les données"
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr "Hibernate3 fournit une nouvelle approche innovatrice pour gérer des données avec des règles de \"visibilité\". Un <emphasis>filtre Hibernate</emphasis> est un filtre global, nommé, paramétré qui peut être activé ou désactivé pour une session Hibernate particulière."
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr "Filtres Hibernate"
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr "Hibernate3 ajoute la capacité de prédéfinir des critères de filtre et d'attacher ces filtres à une classe ou à une collection. Un critère de filtre est la faculté de définir une clause de restriction très similaire à l'attribut \"where\" existant disponible sur une classe et divers éléments d'une collection. Mis à part que ces conditions de filtre peuvent être paramétrées. L'application peut alors prendre la décision à l'exécution si des filtres donnés devraient être activés et quels devraient être leurs paramètres. Des filtres peuvent être utilisés comme des vues de base de données, mais paramétrées dans l'application."
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr "Afin d'utiliser des filtres, ils doivent d'abord être définis, puis attachés aux éléments de mapping appropriés. Pour définir un filtre, utilisez l'élément <literal><filter-def/></literal> dans un élément <literal><hibernate-mapping/></literal> :"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr "Puis, ce filtre peut être attaché à une classe :"
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr "ou à une collection :"
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr "ou même aux deux (ou à plusieurs de chaque) en même temps."
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr "Les méthodes sur <literal>Session</literal> sont : <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, et <literal>disableFilter(String filterName)</literal>. Par défaut, les filtres <emphasis>ne sont pas</emphasis> activés pour une session donnée ; ils doivent être explicitement activés en appelant la méthode <literal>Session.enabledFilter()</literal>, laquelle retourne une instance de l'interface <literal>Filter</literal>. Utiliser le simple filtre défini au-dessus ressemblerait à :"
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr "Notez que des méthodes sur l'interface org.hibernate.Filter autorisent le chaînage de beaucoup de méthodes communes d'Hibernate."
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr "Un exemple complet, utilisant des données temporelles avec une structure de date d'enregistrement effectif :"
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr "Puis, afin de s'assurer que vous pouvez toujours récupérer les enregistrements actuellement effectifs, activez simplement le filtre sur la session avant de récupérer des données des employés :"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr "Dans le HQL ci-dessus, bien que nous ayons seulement mentionné une contrainte de salaire sur les resultats, à cause du filtre activé, la requête retournera seulement les employés actuellement actifs qui ont un salaire supérieur à un million de dollars."
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr "A noter : si vous prévoyez d'utiliser des filtres avec des jointures externes (soit à travers HQL, soit par le chargement) faites attention à la direction de l'expression de condition. Il est plus sûr de la positionner pour les jointures externes à gauche ; en général, placez le paramètre d'abord, suivi du(des) nom(s) de colonne après l'opérateur."
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,642 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr "Mapping d'héritage de classe"
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr "Les trois stratégies"
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr "Hibernate supporte les trois stratégies d'héritage de base :"
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr "une table par hiérarchie de classe (table per class hierarchy)"
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr "une table par classe fille (table per subclass)"
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr "une table par classe concrète (table per concrete class)"
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr "Hibernate supporte en plus une quatrièmestratégie, légèrement différente, qui supporte le polymorphisme :"
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr "le polymorphisme implicite"
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr "Il est possible d'utiliser différentes stratégies de mapping pour différentes branches d'une même hiérarchie d'héritage, et alors d'employer le polymorphisme implicite pour réaliser le polymorphisme à travers toute la hiérarchie. Pourtant, Hibernate ne supporte pas de mélanger des mappings <literal><subclass></literal> et <literal><joined-subclass></literal> et <literal><union-subclass></literal> pour le même élément <literal><class></literal> racine. Il est possible de mélanger ensemble les stratégies d'une table par hiérarchie et d'une table par sous-classe, pour le même élément <literal><class></literal>, en combinant les éléments <literal><subclass></literal> et <literal><join></literal> (voir dessous)."
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr "Il est possible de définir des mappings de <literal>subclass</literal>, <literal>union-subclass</literal>, et <literal>joined-subclass</literal> dans des documents de mapping séparés, directement sous <literal>hibernate-mapping</literal>. Ceci vous permet d'étendre une hiérarchie de classe juste en ajoutant un nouveau fichier de mapping. Vous devez spécifier un attribut <literal>extends</literal> dans le mapping de la sous-classe, en nommant une super-classe précédemment mappée. Note : précédemment cette foncionnalité rendait l'ordre des documents de mapping important. Depuis Hibernate3, l'ordre des fichier de mapping n'importe plus lors de l'utilisation du mot-clef \"extends\". L'ordre à l'intérieur d'un simple fichier de mapping impose encore de définir les classes mères avant les classes filles."
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr "Une table par hiérarchie de classe"
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr "Supposons que nous ayons une interface <literal>Payment</literal>, implémentée par <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. La stratégie une table par hiérarchie serait :"
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr "Une seule table est requise. Une grande limitation de cette stratégie est que les colonnes déclarées par les classes filles, telles que <literal>CCTYPE</literal>, ne peuvent avoir de contrainte <literal>NOT NULL</literal>."
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr "Une table par classe fille"
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr "La stratégie une table par classe fille serait :"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:102
+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 "Quatre tables sont requises. Les trois tables des classes filles ont une clé primaire associée à la table classe mère (le modèle relationnel est une association un-vers-un)."
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr "Une table par classe fille, en utilisant un discriminant"
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr "Notez que l'implémentation Hibernate de la stratégie un table par classe fille ne nécessite pas de colonne discriminante dans la table classe mère. D'autres implémentations de mappers Objet/Relationnel utilisent une autre implémentation de la stratégie une table par classe fille qui nécessite une colonne de type discriminant dans la table de la classe mère. L'approche prise par Hibernate est plus difficile à implémenter mais plus correcte d'une point de vue relationnel. Si vous aimeriez utiliser une colonne discriminante avec la stratégie d'une table par classe fille, vous pourriez combiner l'utilisation de <literal><subclass></literal> et <literal><join></literal>, comme suit :"
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:127
+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 "La déclaration optionnelle <literal>fetch=\"select\"</literal> indique à Hibernate de ne pas récupérer les données de la classe fille <literal>ChequePayment</literal> par une jointure externe lors des requêtes sur la classe mère."
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr "Mélange d'une table par hiérarchie de classe avec une table par classe fille"
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr "Vous pouvez même mélanger les stratégies d'une table par hiérarchie de classe et d'une table par classe fille en utilisant cette approche :"
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr "Pour importe laquelle de ces stratégies, une association polymorphique vers la classe racine <literal>Payment</literal> est mappée en utilisant <literal><many-to-one></literal>."
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr "Une table par classe concrète"
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr "Il y a deux manières d'utiliser la stratégie d'une table par classe concrète. La première est d'employer <literal><union-subclass></literal>."
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr "Trois tables sont nécessaires pour les classes filles. Chaque table définit des colonnes pour toutes les propriétés de la classe, incluant les propriétés héritéés."
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr "La limitation de cette approche est que si une propriété est mappée sur la classe mère, le nom de la colonne doit être le même pour toutes les classes filles. (Nous pourrions être plus souple dans une future version d'Hibernate). La stratégie du générateur d'identifiant n'est pas permise dans l'héritage de classes filles par union, en effet la valeur (NdT : seed) de la clef primaire doit être partagée par toutes les classes filles \"union\" d'une hiérarchie."
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr "Si votre classe mère est abstraite, mappez la avec <literal>abstract=\"true\"</literal>. Bien sûr, si elle n'est pas abstraite, une table supplémentaire (par défaut, <literal>PAYMENT</literal> dans l'exemple ci-dessus) est requise pour contenir des instances de la classe mère."
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr "Une table par classe concrète, en utilisant le polymorphisme implicite"
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr "Une approche alternative est l'emploi du polymorphisme implicite :"
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr "Notez que nulle part nous ne mentionnons l'interface <literal>Payment</literal> explicitement. Notez aussi que des propriétés de <literal>Payment</literal> sont mappées dans chaque classe fille. Si vous voulez éviter des duplications, considérez l'utilisation des entités XML (cf. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> dans la déclaration du <literal>DOCTYPE</literal> et <literal>&allproperties;</literal> dans le mapping)."
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr "L'inconvénient de cette approche est qu'Hibernate ne génère pas d'<literal>UNION</literal>s SQL lors de l'exécution des requêtes polymorphiques."
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr "Pour cette stratégie de mapping, une association polymorphique pour <literal>Payment</literal> est habituellement mappée en utilisant <literal><any></literal>."
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr "Mélange du polymorphisme implicite avec d'autres mappings d'héritage"
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr "Il y a une chose supplémentaire à noter à propos de ce mapping. Puisque les classes filles sont chacune mappées avec leur propre élément <literal><class></literal> (et puisque <literal>Payment</literal> est juste une interface), chaque classe fille pourrait facilement faire partie d'une autre hiérarchie d'héritage ! (Et vous pouvez encore faire des requêtes polymorphiques pour l'interface <literal>Payment</literal>)."
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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 "Encore une fois, nous ne mentionnons pas explicitement <literal>Payment</literal>. Si nous exécutons une requête sur l'interface <literal>Payment</literal> - par exemple, <literal>from Payment</literal> - Hibernate retournera automatiquement les instances de <literal>CreditCardPayment</literal> (et ses classes filles puisqu'elles implémentent aussi <literal>Payment</literal>), <literal>CashPayment</literal> et <literal>ChequePayment</literal> mais pas les instances de <literal>NonelectronicTransaction</literal>."
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr "Limitations"
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr "Il y a certaines limitations à l'approche du \"polymorphisme implicite\" pour la stratégie de mapping d'une table par classe concrète. Il y a plutôt moins de limitations restrictives aux mappings <literal><union-subclass></literal>."
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr "La table suivante montre les limitations des mappings d'une table par classe concrète, et du polymorphisme implicite, dans Hibernate."
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr "Caractéristiques du mapping d'héritage"
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr "Stratégie d'héritage"
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr "many-to-one polymorphique"
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr "one-to-one polymorphique"
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr "one-to-many polymorphique"
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr "many-to-many polymorphique"
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr "<literal>load()/get()</literal> polymorphique"
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr "Requêtes polymorphiques"
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr "Jointures polymorphiques"
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr "Récupération par jointure externe"
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr "une table par hiérarchie de classe"
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr "<many-to-one>"
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr "<one-to-one>"
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr "<one-to-many>"
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr "<many-to-many>"
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr "s.get(Payment.class, id)"
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr "from Payment p"
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr "from Order o join o.payment p"
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr "supportée"
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr "une table par classe fille"
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr "une table par classe concrète (union-subclass)"
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr "<literal><one-to-many></literal> (pour <literal>inverse=\"true\"</literal> seulement)"
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr "une table par classe concrète (polymorphisme implicite)"
+
+#: index.docbook:323
+msgid "<any>"
+msgstr "<any>"
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr "non supporté"
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr "<many-to-any>"
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1220 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr "Améliorer les performances"
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr "Stratégies de chargement"
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr "Une <emphasis>stratégie de chargement</emphasis> est une stratégie qu'Hibernate va utiliser pour récupérer des objets associés si l'application à besoin de naviguer à travers une association. Les stratégies de chargement peuvent être déclarées dans les méta-données de l'outil de mapping objet relationnel ou surchargées par une requête de type HQL ou <literal>Criteria</literal> particulière."
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr "Hibernate3 définit les stratégies de chargement suivantes :"
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr "<emphasis>Chargement par jointure</emphasis> - Hibernate récupère l'instance associée ou la collection dans un même <literal>SELECT</literal>, en utilisant un <literal>OUTER JOIN</literal>."
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Chargement par select</emphasis> - Un second <literal>SELECT</literal> est utilisé pour récupérer l'instance associée ou la collection. A moins que vous ne désactiviez explicitement le chargement tardif en spécifiant <literal>lazy=\"false\"</literal>, ce second select ne sera exécuté que lorsque vous accéderez réellement à l'association."
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Chargement par sous-select</emphasis> - Un second <literal>SELECT</literal> est utilisé pour récupérer les associations pour toutes les entités récupérées dans une requête ou un chargement préalable. A moins que vous ne désactiviez explicitement le chargement tardif en spécifiant <literal>lazy=\"false\"</literal>, ce second select ne sera exécuté que lorsque vous accéderez réellement à l'association."
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr "<emphasis>Chargement par lot</emphasis> - Il s'agit d'une stratégie d'optimisation pour le chargement par select - Hibernate récupère un lot d'instances ou de collections en un seul <literal>SELECT</literal> en spécifiant une liste de clé primaire ou de clé étrangère."
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr "Hibernate fait également la distinction entre :"
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr "<emphasis>Chargement immédiat</emphasis> - Une association, une collection ou un attribut est chargé immédiatement lorsque l'objet auquel appartient cet élément est chargé."
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr "<emphasis>Chargement tardif d'une collection</emphasis> - Une collection est chargée lorque l'application invoque une méthode sur cette collection (il s'agit du mode de chargement par défaut pour les collections)."
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr "<emphasis>Chargement \"super tardif\" d'une collection</emphasis> - les éléments de la collection sont récupérés individuellement depuis la base de données lorsque nécessaire. Hibernate essaie de ne pas charger toute la collection en mémoire sauf si cela est absolument nécessaire (bien adapté aux très grandes collections)."
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr "<emphasis>Chargement par proxy</emphasis> - une association vers un seul objet est chargée lorsqu'une méthode autre que le getter sur l'identifiant est appelée sur l'objet associé."
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>Chargement \"sans proxy\"</emphasis> - une association vers un seul objet est chargée lorsque l'on accède à cet objet. Par rapport au chargement par proxy, cette approche est moins tardif (l'association est quand même chargée même si on n'accède qu'à l'identifiant) mais plus transparente car il n'y a pas de proxy visible dans l'application. Cette approche requiert une instrumentation du bytecode à la compilation et est rarement nécessaire."
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>Chargement tardif des attributs</emphasis> - Un attribut ou un objet associé seul est chargé lorsque l'on y accède. Cette approche requiert une instrumentation du bytecode à la compilation et est rarement nécessaire."
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr "Nous avons ici deux notions orthogonales : <emphasis>quand</emphasis> l'association est chargée et <emphasis>comment</emphasis> (quelle requête SQL est utilisée). Il ne faut pas confondre les deux. Le mode de chargement est utilisé pour améliorer les performances. On peut utiliser le mode tardif pour définir un contrat sur quelles données sont toujours accessibles sur une instance détachée d'une classe particulière."
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr "Travailler avec des associations chargées tardivement"
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr "Par défaut, Hibernate3 utilise le chargement tardif par select pour les collections et le chargement tardif par proxy pour les associations vers un seul objet. Ces valeurs par défaut sont valables pour la plupart des associations dans la plupart des applications."
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr "<emphasis>Note :</emphasis> si vous définissez <literal>hibernate.default_batch_fetch_size</literal>, Hibernate va utiliser l'optimisation du chargement par lot pour le chargement tardif (cette optimisation peut aussi être activée à un niveau de granularité plus fin)."
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr "Cependant, le chargement tardif pose un problème qu'il faut connaitre. L'accès à une association définie comme \"tardive\", hors du contexte d'une session hibernate ouverte, va conduire à une exception. Par exemple :"
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr "Etant donné que la collection des permissions n'a pas été initialisée avant que la <literal>Session</literal> soit fermée, la collection n'est pas capable de se charger. <emphasis>Hibernate ne supporte pas le chargement tardif pour des objets détachés</emphasis>. La solution à ce problème est de déplacer le code qui lit la collection avant le \"commit\" de la transaction."
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr "Une autre alternative est d'utiliser une collection ou une association non \"tardive\" en spécifiant <literal>lazy=\"false\"</literal> dans le mapping de l'association. Cependant il est prévu que le chargement tardif soit utilisé pour quasiment toutes les collections ou associations. Si vous définissez trop d'associtions non \"tardives\" dans votre modèle objet, Hibernate va finir par devoir charger toute la base de données en mémoire à chaque transaction !"
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr "D'un autre côté, on veut souvent choisir un chargement par jointure (qui est par défaut non tardif) à la place du chargement par select dans une transaction particulière. Nous allons maintenant voir comment adapter les stratégies de chargement. Dans Hibernate3 les mécanismes pour choisir une stratégie de chargement sont identiques que l'on ait une association vers un objet simple ou vers une collection."
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr "Personnalisation des stratégies de chargement"
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr "Le chargement par select (mode par défaut) est très vulnérable au problème du N+1 selects, du coup vous pouvez avoir envie d'activer le chargement par jointure dans les fichiers de mapping :"
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr "La stratégie de chargement définie à l'aide du mot <literal>fetch</literal> dans les fichiers de mapping affecte :"
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr "La récupération via <literal>get()</literal> ou <literal>load()</literal>"
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr "La récupération implicite lorsque l'on navigue à travers une association"
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr "Les requêtes de type <literal>Criteria</literal>"
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr "Les requêtes HQL si l'on utilise le chargement par <literal>subselect</literal>"
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr "Quelle que soit la stratégie de chargement que vous utilisez, la partie du graphe d'objets qui est définie comme non \"tardive\" sera chargée en mémoire. Cela peut mener à l'exécution de plusieurs selects successifs pour une seule requête HQL."
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr "On n'utilise pas souvent les documents de mapping pour adapter le chargement. Au lieu de cela, on conserve le comportement par défaut et on le surcharge pour une transaction particulière en utilisant <literal>left join fetch</literal> dans les requêtes HQL. Cela indique à hibernate à Hibernate de charger l'association de manière agressive lors du premier select en utilisant une jointure externe. Dans l'API Criteria vous pouvez utiliser la méthode <literal>setFetchMode(FetchMode.JOIN)</literal>"
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr "Si vous ne vous sentez pas prêt à modifier la stratégie de chargement utilisé par <literal>get()</literal> ou <literal>load()</literal>, vous pouvez juste utiliser une requête de type <literal>Criteria</literal> comme par exemple :"
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr "(Il s'agit de l'équivalent pour Hibernate de ce que d'autres outils de mapping appellent un \"fetch plan\" ou \"plan de chargement\")"
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr "Une autre manière complètement différente d'éviter le problème des N+1 selects est d'utiliser le cache de second niveau."
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr "Proxys pour des associations vers un seul objet"
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr "Le chargement tardif des collections est implémenté par Hibernate en utilisant ses propres implémentations pour des collections persistantes. Si l'on veut un chargement tardif pour des associations vers un seul objet métier il faut utiliser un autre mécanisme. L'entité qui est pointée par l'association doit être masquée derrière un proxy. Hibernate implémente l'initialisation tardive des proxys sur des objets persistents via une mise à jour à chaud du bytecode (à l'aide de l'excellente librairie CGLIB)."
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr "Par défaut, Hibernate génère des proxys (au démarrage) pour toutes les classes persistantes et les utilise pour activer le chargement tardif des associations <literal>many-to-one</literal> et <literal>one-to-one</literal>."
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr "Le fichier de mapping peut déclarer une interface qui sera utilisée par le proxy d'interfaçage pour cette classe à l'aide de l'attribut <literal>proxy</literal>. Par défaut Hibernate utilises une sous classe de la classe persistante. <emphasis>Il faut que les classes pour lesquelles on ajoute un proxy implémentent un constructeur par défaut de visibilité au moins package. Ce constructeur est recommandé pour toutes les classes persistantes !</emphasis>"
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr "Il y a quelques précautions à prendre lorsque l'on étend cette approche à des classes polymorphiques, exemple :"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ " </class>]]>"
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr "Tout d'abord, les instances de <literal>Cat</literal> ne pourront jamais être \"castées\" en <literal>DomesticCat</literal>, même si l'instance sous jacente est une instance de <literal>DomesticCat</literal> :"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instancie un proxy (n'interroge pas la base de données)\n"
+ "if ( cat.isDomesticCat() ) { // interroge la base de données pour initialiser le proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Erreur !\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr "Deuxièmement, il est possible de casser la notion d'<literal>==</literal> des proxy."
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instancie un proxy Cat\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquiert un nouveau proxy DomesticCat\n"
+ "System.out.println(cat==dc); // faux]]>"
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr "Cette situation n'est pas si mauvaise qu'il n'y parait. Même si nous avons deux références à deux objets proxys différents, l'instance de base sera quand même le même objet :"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+ "<![CDATA[cat.setWeight(11.0); // interroge la base de données pour initialiser le proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr "Troisièmement, vous ne pourrez pas utiliser un proxy CGLIB pour une classe <literal>final</literal> ou pour une classe contenant la moindre méthode <literal>final</literal>."
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr "Enfin, si votre objet persistant obtient une ressource à l'instanciation (par example dans les initialiseurs ou dans le contructeur par défaut), alors ces ressources seront aussi obtenues par le proxy. La classe proxy est vraiment une sous classe de la classe persistante."
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr "Ces problèmes sont tous dus aux limitations fondamentales du modèle d'héritage unique de Java. Si vous souhaitez éviter ces problèmes, vos classes persistantes doivent chacune implémenter une interface qui déclare ses méthodes métier. Vous devriez alors spécifier ces interfaces dans le fichier de mapping :"
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr "où <literal>CatImpl</literal> implémente l'interface <literal>Cat</literal> et <literal>DomesticCatImpl</literal> implémente l'interface <literal>DomesticCat</literal>. Ainsi, des proxys pour les instances de <literal>Cat</literal> et <literal>DomesticCat</literal> pourraient être retournées par <literal>load()</literal> ou <literal>iterate()</literal> (Notez que <literal>list()</literal> ne retourne généralement pas de proxy)."
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr "Les relations sont aussi initialisées tardivement. Ceci signifie que vous devez déclarer chaque propriété comme étant de type <literal>Cat</literal>, et non <literal>CatImpl</literal>."
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr "Certaines opérations ne nécessitent pas l'initialisation du proxy"
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr "<literal>equals()</literal>, si la classe persistante ne surcharge pas <literal>equals()</literal>"
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr "<literal>hashCode()</literal>, si la classe persistante ne surcharge pas <literal>hashCode()</literal>"
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr "Le getter de l'identifiant"
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr "Hibernate détectera les classes qui surchargent <literal>equals()</literal> ou <literal>hashCode()</literal>."
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr "Eh choisissant <literal>lazy=\"no-proxy\"</literal> au lieu de <literal>lazy=\"proxy\"</literal> qui est la valeur par défaut, il est possible d'éviter les problèmes liés au transtypage. Il faudra alors une instrumentation du bytecode à la compilation et toutes les opérations résulterons immédiatement en une initialisation du proxy."
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr "Initialisation des collections et des proxys"
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr "Une exception de type <literal>LazyInitializationException</literal> sera renvoyée par hibernate si une collection ou un proxy non initialisé est accédé en dehors de la portée de la <literal>Session</literal>, e.g. lorsque l'entité à laquelle appartient la collection ou qui a une référence vers le proxy est dans l'état \"détachée\"."
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr "Parfois, nous devons nous assurer qu'un proxy ou une collection est initialisée avant de fermer la <literal>Session</literal>. Bien sûr, nous pouvons toujours forcer l'initialisation en appelant par exemple <literal>cat.getSex()</literal> ou <literal>cat.getKittens().size()</literal>. Mais ceci n'est pas très lisible pour les personnes parcourant le code et n'est pas très générique."
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr "Les méthodes statiques <literal>Hibernate.initialize()</literal> et <literal>Hibernate.isInitialized()</literal> fournissent à l'application un moyen de travailler avec des proxys ou des collections initialisés. <literal>Hibernate.initialize(cat)</literal> forcera l'initialisation d'un proxy de <literal>cat</literal>, si tant est que sa <literal>Session</literal> est ouverte. <literal>Hibernate.initialize( cat.getKittens() )</literal> a le même effet sur la collection kittens."
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr "Une autre option est de conserver la <literal>Session</literal> ouverte jusqu'à ce que toutes les collections et tous les proxys aient été chargés. Dans certaines architectures applicatives, particulièrement celles ou le code d'accès aux données via hiberante et le code qui utilise ces données sont dans des couches applicatives différentes ou des processus physiques différents, il peut devenir problématique de garantir que la <literal>Session</literal> est ouverte lorsqu'une collection est initialisée. Il y a deux moyens de traiter ce problème :"
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr "Dans une application web, un filtre de servlet peut être utilisé pour fermer la <literal>Session</literal> uniquement lorsque la requête a été entièrement traitée, lorsque le rendu de la vue est fini (il s'agit du pattern <emphasis>Open Session in View</emphasis>). Bien sûr, cela demande plus d'attention à la bonne gestion des exceptions de l'application. Il est d'une importance vitale que la <literal>Session</literal> soit fermée et la transaction terminée avant que l'on rende la main à l'utilisateur même si une exception survient durant le traitement de la vue. Voir le wiki Hibernate pour des exemples sur le pattern \"Open Session in View\"."
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr "Dans une application avec une couche métier séparée, la couche contenant la logique métier doit \"préparer\" toutes les collections qui seront nécessaires à la couche web avant de retourner les données. Cela signifie que la couche métier doit charger toutes les données et retourner toutes les données déjà initialisées à la couche de présentation/web pour un cas d'utilisation donné. En général l'application appelle la méthode <literal>Hibernate.initialize()</literal> pour chaque collection nécessaire dans la couche web (cet appel doit être fait avant la fermeture de la session) ou bien récupère les collections de manière agressive à l'aide d'une requête HQL avec une clause <literal>FETCH</literal> ou à l'aide du mode <literal>FetchMode.JOIN</literal> pour une requête de type <literal>Criteria</literal>. Cela est en général plus facile si vous utilisez le pattern <emphasis>Command</emphasis> plutôt que <emphasis>Session Facade</emphasis!
>."
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr "Vous pouvez également attacher à une <literal>Session</literal> un objet chargé au préalable à l'aide des méthodes <literal>merge()</literal> ou <literal>lock()</literal> avant d'accéder aux collections (ou aux proxys) non initialisés. Non, Hibernate ne fait pas, et ne doit pas faire, cela automatiquement car cela pourrait introduire une sémantique transactionnelle ad hoc."
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr "Parfois, vous ne voulez pas initialiser une grande collection mais vous avez quand même besoin d'informations sur elle (comme sa taille) ou un sous ensemble de ses données"
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr "Vous pouvez utiliser un filtre de collection pour récupérer sa taille sans l'initialiser :"
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr "La méthode <literal>createFilter()</literal> est également utilisée pour récupérer de manière efficace des sous ensembles d'une collection sans avoir besoin de l'initialiser dans son ensemble."
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr "Utiliser le chargement par lot"
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr "Pour améliorer les performances, Hibernate peut utiliser le chargement par lot ce qui veut dire qu'Hibernate peut charger plusieurs proxys (ou collections) non initialisés en une seule requête lorsque l'on accède à l'un de ces proxys. Le chargement par lot est une optimisation intimement liée à la stratégie de chargement tardif par select. Il y a deux moyens d'activer le chargement par lot : au niveau de la classe et au niveau de la collection."
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr "Le chargement par lot pour les classes/entités est plus simple à comprendre. Imaginez que vous ayez la situation suivante à l'exécution : vous avez 25 instances de <literal>Cat</literal> chargées dans une <literal>Session</literal>, chaque <literal>Cat</literal> a une référence à son <literal>owner</literal>, une <literal>Person</literal>. La classe <literal>Person</literal> est mappée avec un proxy, <literal>lazy=\"true\"</literal>. Si vous itérez sur tous les cats et appelez <literal>getOwner()</literal> sur chacun d'eux, Hibernate exécutera par défaut 25 <literal>SELECT</literal>, pour charger les owners (initialiser le proxy). Vous pouvez paramétrer ce comportement en spécifiant une <literal>batch-size</literal> (taille du lot) dans le mapping de <literal>Person</literal> :"
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr "Hibernate exécutera désormais trois requêtes, en chargeant respectivement 10, 10, et 5 entités."
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr "Vous pouvez aussi activer le chargement par lot pour les collections. Par exemple, si chaque <literal>Person</literal> a une collection chargée tardivement de <literal>Cat</literal>s, et que 10 personnes sont actuellement chargées dans la <literal>Session</literal>, itérer sur toutes les persons générera 10 <literal>SELECT</literal>s, un pour chaque appel de <literal>getCats()</literal>. Si vous activez le chargement par lot pour la collection <literal>cats</literal> dans le mapping de <literal>Person</literal>, Hibernate pourra précharger les collections :"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr "Avec une taille de lot (<literal>batch-size</literal>) de 3, Hibernate chargera respectivement 3, 3, 3, et 1 collections en quatre <literal>SELECT</literal>s. Encore une fois, la valeur de l'attribut dépend du nombre de collections non initialisées dans une <literal>Session</literal> particulière."
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr "Le chargement par lot de collections est particulièrement utile si vous avez des arborescenses récursives d'éléments (typiquement, le schéma facture de matériels). (Bien qu'un <emphasis>sous ensemble</emphasis> ou un <emphasis>chemin matérialisé</emphasis> est sans doute une meilleure option pour des arbres principalement en lecture.)"
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr "Utilisation du chargement par sous select"
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr "Si une collection ou un proxy vers un objet doit être chargé, Hibernate va tous les charger en ré-exécutant la requête orignial dans un sous select. Cela fonctionne de la même manière que le chargement par lot sans la possibilité de fragmenter le chargement."
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr "Utiliser le chargement tardif des propriétés"
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr "Hibernate3 supporte le chargement tardif de propriétés individuelles. La technique d'optimisation est également connue sous le nom de <emphasis>fetch groups</emphasis> (groupes de chargement). Il faut noter qu'il s'agit principalement d'une fonctionnalité marketing car en pratique l'optimisation de la lecture d'un enregistrement est beaucoup plus importante que l'optimisation de la lecture d'une colonne. Cependant, la restriction du chargement à certaines colonnes peut être pratique dans des cas extrèmes, lorsque des tables \"legacy\" possèdent des centaines de colonnes et que le modèle de données ne peut pas être amélioré."
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr "Pour activer le chargement tardif d'une propriété, il faut mettre l'attribut <literal>lazy</literal> sur une propriété particulière du mapping :"
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr "Le chargement tardif des propriétés requiert une instrumentation du bytecode lors de la compilation ! Si les classes persistantes ne sont pas instrumentées, Hibernate ignorera de manière silencieuse le mode tardif et retombera dans le mode de chargement immédiat."
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr "Pour l'instrumentation du bytecode vous pouvez utiliser la tâche Ant suivante :"
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr "Une autre façon (meilleure ?) pour éviter de lire plus de colonnes que nécessaire au moins pour des transactions en lecture seule est d'utiliser les fonctionnalités de projection des requêtes HQL ou Criteria. Cela évite de devoir instrumenter le bytecode à la compilation et est certainement une solution préférable."
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr "Vous pouvez forcer le mode de chargement agressif des propriétés en utilisant <literal>fetch all properties</literal> dans les requêts HQL."
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr "Le cache de second niveau"
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr "Une <literal>Session</literal> Hibernate est un cache de niveau transactionnel des données persistantes. Il est possible de configurer un cache de cluster ou de JVM (de niveau <literal>SessionFactory</literal> pour être exact) défini classe par classe et collection par collection. Vous pouvez même utiliser votr choix de cache en implémentant le pourvoyeur (provider) associé. Faites attention, les caches ne sont jamais avertis des modifications faites dans la base de données par d'autres applications (ils peuvent cependant être configurés pour régulièrement expirer les données en cache)."
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr "Par défaut, Hibernate utilise EHCache comme cache de niveau JVM (le support de JCS est désormais déprécié et sera enlevé des futures versions d'Hibernate). Vous pouvez choisir une autre implémentation en spécifiant le nom de la classe qui implémente <literal>org.hibernate.cache.CacheProvider</literal> en utilisant la propriété <literal>hibernate.cache.provider_class</literal>."
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr "Fournisseur de cache"
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr "Cache"
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr "Classe pourvoyeuse"
+
+#: index.docbook:603
+msgid "Type"
+msgstr "Type"
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr "Support en Cluster"
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr "Cache de requêtes supporté"
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr "Hashtable (ne pas utiliser en production)"
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr "org.hibernate.cache.HashtableCacheProvider"
+
+#: index.docbook:612
+msgid "memory"
+msgstr "mémoire"
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr "<entry>oui</entry>"
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr "EHCache"
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr "org.hibernate.cache.EhCacheProvider"
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr "mémoire, disque"
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr "OSCache"
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr "org.hibernate.cache.OSCacheProvider"
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr "<entry>oui</entry>"
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr "SwarmCache"
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr "org.hibernate.cache.SwarmCacheProvider"
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr "en cluster (multicast ip)"
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr "oui (invalidation de cluster)"
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr "JBoss TreeCache"
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr "org.hibernate.cache.TreeCacheProvider"
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr "en cluster (multicast ip), transactionnel"
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr "oui (replication)"
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr "oui (horloge sync. nécessaire)"
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr "Mapping de Cache"
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr "L'élément <literal><cache></literal> d'une classe ou d'une collection à la forme suivante :"
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr "<literal>usage</literal> (requis) spécifie la stratégie de cache : <literal>transactionel</literal>, <literal>lecture-écriture</literal>, <literal>lecture-écriture non stricte</literal> ou <literal>lecture seule</literal>"
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr "<literal>region</literal> (optionnel, par défaut il s'agit du nom de la classe ou du nom de role de la collection) spécifie le nom de la région du cache de second niveau"
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr "<literal>include</literal> (optionnel, par défaut <literal>all</literal>) <literal>non-lazy</literal> spécifie que les propriétés des entités mappées avec <literal>lazy=\"true\"</literal> ne doivent pas être mises en cache lorsque le chargement tardif des attributs est activé."
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr "Alternativement (voir préférentiellement), vous pouvez spécifier les éléments <literal><class-cache></literal> et <literal><collection-cache></literal> dans <literal>hibernate.cfg.xml</literal>."
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr "L'attribut <literal>usage</literal> spécifie une <emphasis>stratégie de concurrence d'accès au cache</emphasis>."
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr "Strategie : lecture seule"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr "Si votre application a besoin de lire mais ne modifie jamais les instances d'une classe, un cache <literal>read-only</literal> peut être utilisé. C'est la stratégie la plus simple et la plus performante. Elle est même parfaitement sûre dans un cluster."
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr "Stratégie : lecture/écriture"
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr "Si l'application a besoin de mettre à jour des données, un cache <literal>read-write</literal> peut être approprié. Cette stratégie ne devrait jamais être utilisée si votre application nécessite un niveau d'isolation transactionnelle sérialisable. Si le cache est utilisé dans un environnement JTA, vous devez spécifier <literal>hibernate.transaction.manager_lookup_class</literal>, fournissant une stratégie pour obtenir le <literal>TransactionManager</literal> JTA. Dans d'autres environnements, vous devriez vous assurer que la transation est terminée à l'appel de <literal>Session.close()</literal> ou <literal>Session.disconnect()</literal>. Si vous souhaitez utiliser cette stratégie dans un cluster, vous devriez vous assurer que l'implémentation de cache utilisée supporte le vérrouillage. Ce que ne font <emphasis>pas</emphasis> les pourvoyeurs caches fournis."
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr "Stratégie : lecture/écriture non stricte"
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr "Si l'application besoin de mettre à jour les données de manière occasionnelle (qu'il est très peu probable que deux transactions essaient de mettre à jour le même élément simultanément) et qu'une isolation transactionnelle stricte n'est pas nécessaire, un cache <literal>nonstrict-read-write</literal> peut être approprié. Si le cache est utilisé dans un environnement JTA, vous devez spécifier <literal>hibernate.transaction.manager_lookup_class</literal>. Dans d'autres environnements, vous devriez vous assurer que la transation est terminée à l'appel de <literal>Session.close()</literal> ou <literal>Session.disconnect()</literal>"
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "Stratégie : transactionelle"
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr "La stratégie de cache <literal>transactional</literal> supporte un cache complètement transactionnel comme, par exemple, JBoss TreeCache. Un tel cache ne peut être utilisé que dans un environnement JTA et vous devez spécifier <literal>hibernate.transaction.manager_lookup_class</literal>."
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr "Aucun des caches livrés ne supporte toutes les stratégies de concurrence. Le tableau suivant montre quels caches sont compatibles avec quelles stratégies de concurrence."
+
+#: index.docbook:775
+msgid "read-only"
+msgstr "Cache"
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr "read-only (lecture seule)"
+
+#: index.docbook:777
+msgid "read-write"
+msgstr "nonstrict-read-write (lecture-écriture non stricte)"
+
+#: index.docbook:778
+msgid "transactional"
+msgstr "read-write (lecture-ériture)"
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr "<entry>oui</entry>"
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr "Gérer les caches"
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr "A chaque fois que vous passez un objet à la méthode <literal>save()</literal>, <literal>update()</literal> ou <literal>saveOrUpdate()</literal> et à chaque fois que vous récupérez un objet avec <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, cet objet est ajouté au cache interne de la <literal>Session</literal>."
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr "Lorsqu'il y a un appel à la méthode <literal>flush()</literal>, l'état de cet objet va être synchronisé avec la base de données. Si vous ne voulez pas que cette synchronisation ait lieu ou si vous traitez un grand nombre d'objets et que vous avez besoin de gérer la mémoire de manière efficace, vous pouvez utiliser la méthode <literal>evict()</literal> pour supprimer l'objet et ses collections dépendantes du cache de la session"
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr "La <literal>Session</literal> dispose aussi de la méthode <literal>contains()</literal> pour déterminer si une instance appartient au cache de la session."
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr "Pour retirer tous les objets du cache session, appelez <literal>Session.clear()</literal>"
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr "Pour le cache de second niveau, il existe des méthodes définies dans <literal>SessionFactory</literal> pour retirer des instances du cache, la classe entière, une instance de collection ou le rôle entier d'une collection."
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr "Le <literal>CacheMode</literal> contrôle comme une session particulière interragit avec le cache de second niveau"
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr "<literal>CacheMode.NORMAL</literal> - lit et écrit les items dans le cache de second niveau"
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr "<literal>CacheMode.GET</literal> - lit les items dans le cache de second niveau mais ne les écrit pas sauf dans le cache d'une mise à jour d'une donnée"
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr "<literal>CacheMode.PUT</literal> - écrit les items dans le cache de second niveau mais ne les lit pas dans le cache de second niveau"
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr "<literal>CacheMode.REFRESH</literal> - écrit les items dans le cache de second niveau mais ne les lit pas dans le cache de second niveau, outrepasse l'effet de<literal>hibernate.cache.use_minimal_puts</literal>, en forçant un rafraîchissement du cache de second niveau pour chaque item lu dans la base"
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr "Pour parcourir le contenu du cache de second niveau ou la région du cache dédiée au requêtes, vous pouvez utiliser l'API <literal>Statistics</literal> API:"
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr "Vous devez pour cela activer les statistiques et optionnellement forcer Hibernate à conserver les entrées dans le cache sous un format plus compréhensible pour l'utilisateur :"
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr "Le cache de requêtes"
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr "Les résultats d'une requête peuvent aussi être placés en cache. Ceci n'est utile que pour les requêtes qui sont exécutées avec les mêmes paramètres. Pour utiliser le cache de requêtes, vous devez d'abord l'activer :"
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr "<![CDATA[hibernate.cache.use_query_cache true]]>"
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr "Ce paramètre amène la création de deux nouvelles régions dans le cache, une qui va conserver le résultat des requêtes mises en cache (<literal>org.hibernate.cache.StandardQueryCache</literal>) et l'autre qui va conserver l'horodatage des mises à jour les plus récentes effectuées sur les tables requêtables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Il faut noter que le cache de requête ne conserve pas l'état des entités, il met en cache uniquement les valeurs de l'identifiant et les valeurs de types de base (?). Le cache de requête doit toujours être utilisé avec le cache de second niveau pour être efficace."
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr "La plupart des requêtes ne retirent pas de bénéfice pas du cache, donc par défaut les requêtes ne sont pas mises en cache. Pour activer le cache, appelez <literal>Query.setCacheable(true)</literal>. Cet appel permet de vérifier si les résultats sont en cache ou non, voire d'ajouter ces résultats si la requête est exécutée."
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr "Si vous avez besoin de contrôler finement les délais d'expiration du cache, vous pouvez spécifier une région de cache nommée pour une requête particulière en appelant <literal>Query.setCacheRegion()</literal>."
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr "Si une requête doit forcer le rafraîchissement de sa région de cache, vous devez appeler <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. C'est particulièrement utile lorsque les données peuvent avoir été mises à jour par un processus séparé (e.g. elles n'ont pas été modifiées par Hibernate). Cela permet à l'application de rafraîchir de manière sélective les résultats d'une requête particulière. Il s'agit d'une alternative plus efficace à l'éviction d'une région du cache à l'aide de la méthode <literal>SessionFactory.evictQueries()</literal>."
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr "Comprendre les performances des Collections"
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr "Nous avons déjà passé du temps à discuter des collections. Dans cette section, nous allons traiter du comportement des collections à l'exécution."
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr "Classification"
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr "Hibernate définit trois types de collections :"
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr "les collections de valeurs"
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr "les associations un-vers-plusieurs"
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr "les associations plusieurs-vers-plusieurs"
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr "Cette classification distingue les différentes relations entre les tables et les clés étrangères mais ne nous apprend rien de ce que nous devons savoir sur le modèle relationnel. Pour comprendre parfaitement la structure relationnelle et les caractéristiques des performances, nous devons considérer la structure de la clé primaire qui est utilisée par Hibernate pour mettre à jour ou supprimer les éléments des collections. Celà nous amène aux classifications suivantes :"
+
+#: index.docbook:994
+msgid "sets"
+msgstr "collections indexées"
+
+#: index.docbook:997
+msgid "bags"
+msgstr "sets"
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr "bags"
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr "Toutes les collections indexées (maps, lists, arrays) ont une clé primaire constituée des colonnes clé (<literal><key></literal>) et <literal><index></literal>. Avec ce type de clé primaire, la mise à jour de collection est en général très performante - la clé primaire peut être indexées efficacement et un élément particulier peut être localisé efficacement lorsqu'Hibernate essaie de le mettre à jour ou de le supprimer."
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr "Les Sets ont une clé primaire composée de <literal><key></literal> et des colonnes représentant l'élément. Elle est donc moins efficace pour certains types de collections d'éléments, en particulier les éléments composites, les textes volumineux ou les champs binaires ; la base de données peut ne pas être capable d'indexer aussi efficacement une clé primaire aussi complexe. Cependant, pour les associations un-vers-plusieurs ou plusieurs-vers-plusieurs, spécialement lorsque l'on utilise des entités ayant des identifiants techniques, il est probable que cela soit aussi efficace (note : si vous voulez que <literal>SchemaExport</literal> créé effectivement la clé primaire d'un <literal><set></literal> pour vous, vous devez déclarer toutes les colonnes avec <literal>not-null=\"true\"</literal>)."
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr "Le mapping à l'aide d'<literal><idbag></literal> définit une clé de substitution ce qui leur permet d'être très efficaces lors de la mise à jour. En fait il s'agit du meilleur cas de mise à jour d'une collection"
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr "Le pire cas intervient pour les Bags. Dans la mesure où un bag permet la duplications des éléments et n'a pas de colonne d'index, aucune clé primaire ne peut être définie. Hibernate n'a aucun moyen de distinguer des enregistrements dupliqués. Hibernate résout ce problème en supprimant complètement les enregistrements (via un simple <literal>DELETE</literal>), puis en recréant la collection chaque fois qu'elle change. Ce qui peut être très inefficace."
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr "Notez que pour une relation un-vers-plusieurs, la \"clé primaire\" peut ne pas être la clé primaire de la table en base de données - mais même dans ce cas, la classification ci-dessus reste utile (Elle explique comment Hibernate \"localise\" chaque enregistrement de la collection)."
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr "Les lists, les maps, les idbags et les sets sont les collections les plus efficaces pour la mise à jour"
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr "La discussion précédente montre clairement que les collections indexées et (la plupart du temps) les sets, permettent de réaliser le plus efficacement les opérations d'ajout, de suppression ou de modification d'éléments."
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr "Il existe un autre avantage qu'ont les collections indexées sur les Sets dans le cadre d'une association plusieurs vers plusieurs ou d'une collection de valeurs. A cause de la structure inhérente d'un <literal>Set</literal>, Hibernate n'effectue jamais d'<literal>UPDATE</literal> quand un enregistrement est modifié. Les modifications apportées à un <literal>Set</literal> se font via un <literal>INSERT</literal> et <literal>DELETE</literal> (de chaque enregistrement). Une fois de plus, ce cas ne s'applique pas aux associations un vers plusieurs."
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr "Après s'être rappelé que les tableaux ne peuvent pas être chargés tardivement, nous pouvons conclure que les lists, les maps et les idbags sont les types de collections (non inversées) les plus performants, avec les sets pas loin derrières. Les sets son le type de collection le plus courant dans les applications Hibernate. Cela est du au fait que la sémantique des \"set\" est la plus naturelle dans le modèle relationnel."
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr "Cependant, dans des modèles objet bien conçus avec Hibernate, on voit souvent que la plupart des collections sont en fait des associations \"un-vers-plusieurs\" avec <literal>inverse=\"true\"</literal>. Pour ces associations, les mises à jour sont gérées au niveau de l'association \"plusieurs-vers-un\" et les considérations de performance de mise à jour des collections ne s'appliquent tout simplement pas dans ces cas là ."
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr "Les Bags et les lists sont les plus efficaces pour les collections inverse"
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr "Avant que vous n'oubliez les bags pour toujours, il y a un cas précis où les bags (et les lists) sont bien plus performants que les sets. Pour une collection marquée comme <literal>inverse=\"true\"</literal> (le choix le plus courant pour un relation un vers plusieurs bidirectionnelle), nous pouvons ajouter des éléments à un bag ou une list sans avoir besoin de l'initialiser (fetch) les éléments du sac! Ceci parce que <literal>Collection.add()</literal> ou <literal>Collection.addAll()</literal> doit toujours retourner vrai pour un bag ou une <literal>List</literal> (contrairement au <literal>Set</literal>). Cela peut rendre le code suivant beaucoup plus rapide."
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ " Child c = new Child();\n"
+ " c.setParent(p);\n"
+ " p.getChildren().add(c); //pas besoin de charger la collection !\n"
+ " sess.flush();]]>"
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr "Suppression en un coup"
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr "Parfois, effacer les éléments d'une collection un par un peut être extrêmement inefficace. Hibernate n'est pas totalement stupide, il sait qu'il ne faut pas le faire dans le cas d'une collection complètement vidée (lorsque vous appellez <literal>list.clear()</literal>, par exemple). Dans ce cas, Hibernate fera un simple <literal>DELETE</literal> et le travail est fait !"
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr "Supposons que nous ajoutions un élément dans une collection de taille vingt et que nous enlevions ensuite deux éléments. Hibernate effectuera un <literal>INSERT</literal> puis deux <literal>DELETE</literal> (à moins que la collection ne soit un bag). Ce qui est souhaitable."
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr "Cependant, supposons que nous enlevions dix huit éléments, laissant ainsi deux éléments, puis que nous ajoutions trois nouveaux éléments. Il y a deux moyens de procéder."
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr "effacer dix huit enregistrements un à un puis en insérer trois"
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr "effacer la totalité de la collection (en un <literal>DELETE</literal> SQL) puis insérer les cinq éléments restant un à un"
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr "Hibernate n'est pas assez intelligent pour savoir que, dans ce cas, la seconde méthode est plus rapide (Il plutôt heureux qu'Hibernate ne soit pas trop intelligent ; un tel comportement pourrait rendre l'utilisation de triggers de bases de données plutôt aléatoire, etc...)."
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr "Heureusement, vous pouvez forcer ce comportement lorsque vous le souhaitez, en liberant (c'est-à -dire en déréférençant) la collection initiale et en retournant une collection nouvellement instanciée avec les éléments restants. Ceci peut être très pratique et très puissant de temps en temps."
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr "Bien sûr, la suppression en un coup ne s'applique pas pour les collections qui sont mappées avec <literal>inverse=\"true\"</literal>."
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr "Moniteur de performance"
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr "L'optimisation n'est pas d'un grand intérêt sans le suivi et l'accès aux données de performance. Hibernate fournit toute une panoplie de rapport sur ses opérations internes. Les statistiques dans Hibernate sont fournies par <literal>SessionFactory</literal>."
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr "Suivi d'une SessionFactory"
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr "Vous pouvez accéder au métriques d'une <literal>SessionFactory</literal> de deux manières. La première option est d'appeler <literal>sessionFactory.getStatistics()</literal> et de lire ou d'afficher les <literal>Statistics</literal> vous même."
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr "Hibernate peut également utiliser JMX pour publier les métriques si vous activez le MBean <literal>StatisticsService</literal>. Vous pouvez activer un seul MBean pour toutes vos <literal>SessionFactory</literal> ou un par factory. Voici un code qui montre un exemple de configuration minimaliste :"
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr "TODO: Cela n'a pas de sens : dans le premier cs on récupère et on utilise le MBean directement. Dans le second, on doit fournir le nom JNDI sous lequel est retenu la fabrique de session avant de l'utiliser. Pour cela il faut utiliser <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr "Vous pouvez (dés)activer le suivi pour une <literal>SessionFactory</literal>"
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr "au moment de la configuration en mettant <literal>hibernate.generate_statistics</literal> Ã <literal>false</literal>"
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr "Ã chaud avec <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> ou <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr "Les statistiques peuvent être remises à zéro de manière programmatique à l'aide de la méthode <literal>clear()</literal> Un résumé peut être envoyé à un logger (niveau info) à l'aide de la méthode <literal>logSummary()</literal>"
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr "Métriques"
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr "Hibernate fournit un certain nombre de métriques, qui vont des informations très basiques aux informations très spécialisées qui ne sont appropriées que dans certains scenarii. Tous les compteurs accessibles sont décrits dans l'API de l'interface <literal>Statistics</literal> dans trois catégories :"
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr "Les métriques relatives à l'usage général de la <literal>Session</literal> comme le nombre de sessions ouvertes, le nombre de connexions JDBC récupérées, etc..."
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr "Les métriques relatives aux entités, collections, requêtes et caches dans leur ensemble (métriques globales),"
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr "Les métriques détaillées relatives à une entité, une collection, une requête ou une région de cache particulière."
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr "Par exemple, vous pouvez vérifier l'accès au cache ainsi que le taux d'éléments manquants et de mise à jour des entités, collections et requêtes et le temps moyen que met une requête. Il faut faire attention au fait que le nombre de millisecondes est sujet à approximation en Java. Hibernate est lié à la précision de la machine virtuelle, sur certaines plateformes, cela n'offre qu'une précision de l'ordre de 10 secondes."
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr "Des accesseurs simples sont utilisés pour accéder aux métriques globales (e.g. celles qui ne sont pas liées à une entité, collection ou région de cache particulière). Vous pouvez accéder aux métriques d'une entité, collection, région de cache particulière à l'aide de son nom et à l'aide de sa représentation HQL ou SQL pour une requête. Référez vous à la javadoc des APIS <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> pour plus d'informations. Le code ci-dessous montre un exemple simple :"
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+
+#: index.docbook:1317
+msgid "appended paragraph 1"
+msgstr "Pour travailler sur toutes les entités, collections, requêtes et régions de cache, vous pouvez récupérer la liste des noms des entités, collections, requêtes et régions de cache avec les méthodes : <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, et <literal>getSecondLevelCacheRegionNames()</literal>."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,660 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr "Classes persistantes"
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr "Les classes persistantes sont les classes d'une application qui implémentent les entités d'un problème métier (ex. Client et Commande dans une application de commerce électronique). Toutes les instances d'une classe persistante ne sont pas forcément dans l'état persistant - au lieu de cela, une instance peut être éphémère (NdT : transient) ou détachée."
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr "Hibernate fonctionne de manière optimale lorsque ces classes suivent quelques règles simples, aussi connues comme le modèle de programmation Plain Old Java Object (POJO). Cependant, aucune de ces règles ne sont des besoins absolus. En effet, Hibernate3 suppose très peu de choses à propos de la nature de vos objets persistants. Vous pouvez exprimer un modèle de domaine par d'autres moyens : utiliser des arbres d'instances de <literal>Map</literal>, par exemple."
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr "Un exemple simple de POJO"
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr "Toute bonne application Java nécessite une classe persistante représentant les félins."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ "\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() );\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr "Il y a quatre règles à suivre ici :"
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr "Implémenter un constructeur sans argument"
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr "<literal>Cat</literal> a un constructeur sans argument. Toutes les classes persistantes doivent avoir un constructeur par défaut (lequel peut ne pas être public) pour qu'Hibernate puissent les instancier en utilisant <literal>Constructor.newInstance()</literal>. Nous recommandons fortement d'avoir un constructeur par défaut avec au moins une visibilité <emphasis>paquet</emphasis> pour la génération du proxy à l'exécution dans Hibernate."
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr "Fournir une propriété d'indentifiant (optionnel)"
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr "<literal>Cat</literal> possède une propriété appelée <literal>id</literal>. Cette propriété mappe la valeur de la colonne de clé primaire de la table d'une base de données.La propriété aurait pu s'appeler complètement autrement, et son type aurait pu être n'importe quel type primitif, n'importe quel \"encapsuleur\" de type primitif, <literal>java.lang.String</literal> ou <literal>java.util.Date</literal>. (Si votre base de données héritée possède des clés composites, elles peuvent être mappées en utilisant une classe définie par l'utilisateur et possédant les propriétés associées aux types de la clé composite - voir la section concernant les identifiants composites plus tard)."
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr "La propriété d'identifiant est strictement optionnelle. Vous pouver l'oublier et laisser Hibernate s'occuper des identifiants de l'objet en interne. Toutefois, nous ne le recommandons pas."
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr "En fait, quelques fonctionnalités ne sont disponibles que pour les classes déclarant un identifiant de propriété :"
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr "Les réattachements transitifs pour les objets détachés (mise à jour en cascade ou fusion en cascade) - voir"
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr "Session.saveOrUpdate()"
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr "Session.merge()"
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr "Nous recommandons que vous déclariez les propriétés d'identifiant de manière uniforme. Nous recommandons également que vous utilisiez un type nullable (ie. non primitif)."
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr "Favoriser les classes non finales (optionnel)"
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr "Une fonctionnalité clef d'Hibernate, les <emphasis>proxies</emphasis>, nécessitent que la classe persistente soit non finale ou qu'elle soit l'implémentation d'une interface qui déclare toutes les méthodes publiques."
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr "Vous pouvez persister, grâce à Hibernate, les classes <literal>final</literal> qui n'implémentent pas d'interface, mais vous ne pourrez pas utiliser les proxies pour les chargements d'associations paresseuses - ce qui limitera vos possibilités d'ajustement des performances."
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr "Vous devriez aussi éviter de déclarer des méthodes <literal>public final</literal> sur des classes non-finales. Si vous voulez utiliser une classe avec une méthode <literal>public final</literal>, vous devez explicitement désactiver les proxies en paramétrant <literal>lazy=\"false\"</literal>."
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr "Déclarer les accesseurs et mutateurs des attributs persistants (optionnel)"
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr "<literal>Cat</literal> déclare des mutateurs pour toutes ses champs persistants. Beaucoup d'autres solutions de mapping Objet/relationnel persistent directement les variables d'instance. Nous pensons qu'il est bien mieux de fournir une indirection entre le schéma relationnel et les structures de données internes de la classe. Par défaut, Hibernate persiste les propriétés suivant le style JavaBean, et reconnaît les noms de méthodes de la forme <literal> getFoo</literal>, <literal>isFoo</literal> et <literal>setFoo</literal>. Nous pouvons changer pour un accès direct aux champs pour des propriétés particulières, si besoin est."
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr "Les propriétés <emphasis>n'ont pas</emphasis> à être déclarées publiques - Hibernate peut persister une propriété avec un paire de getter/setter de visibilité par défault, <literal>protected</literal> ou <literal> private</literal>."
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr "Implémenter l'héritage"
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr "Une sous-classe doit également suivre la première et la seconde règle. Elle hérite sa propriété d'identifiant de <literal>Cat</literal>."
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr "Implémenter <literal>equals()</literal> et <literal>hashCode()</literal>"
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr "Vous devez surcharger les méthodes <literal>equals()</literal> et <literal>hashCode()</literal> si vous"
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr "avez l'intention de mettre des instances de classes persistantes dans un <literal>Set</literal> (la manière recommandée pour représenter des associations pluri-valuées) <emphasis>et</emphasis>"
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr "avez l'intention d'utiliser le réattachement d'instances détachées"
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr "Hibernate garantit l'équivalence de l'identité persistante (ligne de base de données) et l'identité Java seulement à l'intérieur de la portée d'une session particulière. Donc dès que nous mélangeons des instances venant de différentes sessions, nous devons implémenter <literal>equals()</literal> et <literal>hashCode()</literal> si nous souhaitons avoir une sémantique correcte pour les <literal>Set</literal>s."
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr "La manière la plus évidente est d'implémenter <literal>equals()</literal>/<literal>hashCode()</literal> en comparant la valeur de l'identifiant des deux objets. Si cette valeur est identique, les deux doivent représenter la même ligne de base de données, ils sont donc égaux (si les deux sont ajoutés à un <literal>Set</literal>, nous n'aurons qu'un seul élément dans le <literal>Set</literal>). Malheureusement, nous ne pouvons pas utiliser cette approche avec des identifiants générés ! Hibernate n'assignera de valeur d'identifiant qu'aux objets qui sont persistants, une instance nouvellement créée n'aura donc pas de valeur d'identifiant ! De plus, si une instance est non sauvegardée et actuellement dans un <literal>Set</literal>, le sauvegarder assignera une valeur d'identifiant à l'objet. Si <literal>equals()</literal> et <literal>hashCode()</literal> sont basées sur la valeur de l'identifiant, le code de hachage devrait changer, rompant le contrat!
du <literal>Set</literal>. Regardez sur le site web d'Hibernate pour une discussion complète de ce problème. Notez que ceci n'est pas un problème d'Hibernate, mais la sémantique normale de Java pour l'identité d'un objet et l'égalité."
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr "Nous recommandons donc d'implémenter <literal>equals()</literal> et <literal>hashCode()</literal> en utilisant <emphasis> l'égalité par clé métier</emphasis>.L'égalité par clé métier signifie que la méthode <literal>equals()</literal> compare uniquement les propriétés qui forment une clé métier, une clé qui identifierait notre instance dans le monde réel (une clé candidate <emphasis>naturelle</emphasis>) :"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr "Notez qu'une clef métier ne doit pas être solide comme une clef primaire de base de données (voir <xref linkend=\"transactions-basics-identity\"/>). Les propriétés immuables ou uniques sont généralement de bonnes candidates pour une clef métier."
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr "Modèles dynamiques"
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr "Notez que la fonctionnalités suivantes sont actuellement considérées comme expérimentales et peuvent changer dans un futur proche."
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr "Les entités persistantes ne doivent pas nécessairement être représentées comme des classes POJO ou des objets JavaBean à l'exécution. Hibernate supporte aussi les modèles dynamiques (en utilisant des <literal>Map</literal>s de <literal>Map</literal>s à l'exécution) et la représentation des entités comme des arbres DOM4J. Avec cette approche, vous n'écrivez pas de classes persistantes, seulement des fichiers de mapping."
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr "Par défaut, Hibernate fonctionne en mode POJO normal. Vous pouvez paramétrer un mode de représentation d'entité par défaut pour une <literal>SessionFactory</literal> particulière en utilisant l'option de configuration <literal>default_entity_mode</literal> (voir <xref linkend=\"configuration-optional-properties\"/>)."
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr "Les exemples suivants démontrent la représentation utilisant des <literal>Map</literal>s. D'abord, dans le fichier de mapping, un <literal>entity-name</literal> doit être déclaré au lieu (ou en plus) d'un nom de classe :"
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr "Notez que même si des associations sont déclarées en utilisant des noms de classe cible, le type de cible d'une association peut aussi être une entité dynamique au lieu d'un POJO."
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr "Après avoir configuré le mode d'entité par défaut à <literal>dynamic-map</literal> pour la <literal>SessionFactory</literal>, nous pouvons lors de l'exécution fonctionner avec des <literal>Map</literal>s de <literal>Map</literal>s :"
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr "Les avantages d'un mapping dynamique sont un gain de temps pour le prototypage sans la nécessité d'implémenter les classes d'entité. Pourtant, vous perdez la vérification du typage au moment de la compilation et aurez plus d'exceptions à gérer lors de l'exécution. Grâce au mapping d'Hibernate, le schéma de la base de données peut facilement être normalisé et solidifié, permettant de rajouter une implémentation propre du modèle de domaine plus tard."
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr "Les modes de représentation d'une entité peut aussi être configuré par <literal>Session</literal> :"
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr "Veuillez noter que l'appel à <literal>getSession()</literal> en utilisant un <literal>EntityMode</literal> se fait sur l'API <literal>Session</literal>, pas <literal>SessionFactory</literal>. De cette manière, la nouvelle <literal>Session</literal> partage les connexions JDBC, transactions et autres informations de contexte sous-jacentes. Cela signifie que vous n'avez pas à appeler <literal>flush()</literal> et <literal>close()</literal> sur la <literal>Session</literal> secondaire, et laissez aussi la gestion de la transaction et de la connexion à l'unité de travail primaire."
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr "Plus d'informations à propos de la représentation XML peuvent être trouvées dans <xref linkend=\"xml\"/>."
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr "Tuplizers"
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr "<literal>org.hibernate.tuple.Tuplizer</literal>, et ses sous-interfaces, sont responsables de la gestion d'une représentation particulière d'un morceau de données, en fonction du <literal>org.hibernate.EntityMode</literal> de réprésentation. Si un morceau donné de données est pensé comme une structure de données, alors un tuplizer est la chose qui sait comment créer une telle structure de données, comment extraire des valeurs et injecter des valeurs dans une telle structure de données. Par exemple, pour le mode d'entité POJO, le tuplizer correspondant sait comment créer le POJO à travers son constructeur et comment accéder aux propriétés du POJO utilisant les accesseurs de la propriété définie. Il y a deux types de Tuplizers haut niveau, représenté par les interfaces <literal>org.hibernate.tuple.EntityTuplizer</literal> et <literal>org.hibernate.tuple.ComponentTuplizer</literal>. Les <literal>EntityTuplizer</literal>s sont responsables de la g!
estion des contrats mentionnés ci-dessus pour les entités, alors que les <literal>ComponentTuplizer</literal>s s'occupent des composants."
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr "Les utilisateurs peuvent aussi brancher leurs propres tuplizers. Peut-être vous est-il nécessaire qu'une implémentation de <literal>java.util.Map</literal> autre que <literal>java.util.HashMap</literal> soit utilisée dans le mode d'entité dynamic-map ; ou peut-être avez-vous besoin de définir une statégie de génération de proxy différente de celle utilisée par défaut. Les deux devraient être effectuées en définissant une implémentation de tuplizer utilisateur. Les définitions de tuplizers sont attachées au mapping de l'entité ou du composant qu'ils sont censés gérer. Retour à l'exemple de notre entité utilisateur :"
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr "TODO: Document user-extension framework in the property and proxy packages"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr "Préface"
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "Travailler dans les deux univers que sont l'orienté objet et la base de données relationnelle peut être lourd et consommateur en temps dans le monde de l'entreprise d'aujourd'hui. Hibernate est un outil de mapping objet/relationnel pour le monde Java. Le terme mapping objet/relationnel (ORM) décrit la technique consistant à faire le lien entre la représentation objet des données et sa représentation relationnelle basée sur un schéma SQL."
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Non seulement, Hibernate s'occupe du transfert des classes Java dans les tables de la base de données (et des types de données Java dans les types de données SQL), mais il permet de requêter les données et propose des moyens de les récupérer. Il peut donc réduire de manière significative le temps de développement qui aurait été autrement perdu dans une manipulation manuelle des données via SQL et JDBC."
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "Le but d'Hibernate est de libérer le développeur de 95 pourcent des tâches de programmation liées à la persistance des données communes. Hibernate n'est probablement pas la meilleure solution pour les applications centrées sur les données qui n'utilisent que les procédures stockées pour implémenter la logique métier dans la base de données, il est le plus utile dans les modèles métier orientés objets dont la logique métier est implémentée dans la couche Java dite intermédiaire. Cependant, Hibernate vous aidera à supprimer ou à encapsuler le code SQL spécifique à votre base de données et vous aidera sur la tâche commune qu'est la transformation des données d'une représentation tabulaire à une représentation sous forme de graphe d'objets."
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "Si vous êtes nouveau dans Hibernate et le mapping Objet/Relationnel voire même en Java, suivez ces quelques étapes :"
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "Lisez <xref linkend=\"tutorial\"/> pour un didacticiel plus long avec plus d'instructions étape par étape."
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr "Lisez <xref linkend=\"architecture\"/> pour comprendre les environnements dans lesquels Hibernate peut être utilisé."
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "Regardez le répertoire <literal>eg</literal> de la distribution Hibernate, il contient une application simple et autonome. Copiez votre pilote JDBC dans le répertoire <literal>lib/</literal> et éditez <literal>src/hibernate.properties</literal>, en positionnant correctement les valeurs pour votre base de données. A partir d'une invite de commande dans le répertoire de la distribution, tapez <literal>ant eg</literal> (cela utilise Ant), ou sous Windows tapez <literal>build eg</literal>."
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "Faîtes de cette documentation de référence votre principale source d'information. Pensez à lire <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) si vous avez besoin de plus d'aide avec le design d'applications ou si vous préférez un tutoriel pas à pas. Visitez aussi http://caveatemptor.hibernate.org et téléchargez l'application exemple pour Java Persistence with Hibernate."
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr "Les questions les plus fréquemment posées (FAQs) trouvent leur réponse sur le site web Hibernate."
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr "Des démos, exemples et tutoriaux de tierces personnes sont référencés sur le site web Hibernate."
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "La zone communautaire (Community Area) du site web Hibernate est une bonne source d'information sur les design patterns et sur différentes solutions d'intégration d'Hibernate (Tomcat, JBoss, Spring Framework, Struts, EJB, etc)."
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "Si vous avez des questions, utilisez le forum utilisateurs du site web Hibernate. Nous utilisons également l'outil de gestion des incidents JIRA pour tout ce qui est rapports de bogue et demandes d'évolution. Si vous êtes intéressé par le développement d'Hibernate, joignez-vous à la liste de diffusion de développement."
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "Le développement commercial, le support de production et les formations à Hibernate sont proposés par JBoss Inc (voir http://www.hibernate.org/SupportTraining/). Hibernate est un projet Open Source professionnel et un composant critique de la suite de produits JBoss Enterprise Middleware System (JEMS)."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,672 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr "Requêtes par critères"
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr "Hibernate offre une API d'interrogation par critères intuitive et extensible."
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr "Créer une instance de <literal>Criteria</literal>"
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr "L'interface <literal>net.sf.hibernate.Criteria</literal> représente une requête sur une classe persistente donnée. La <literal>Session</literal> fournit les instances de <literal>Criteria</literal>."
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr "Restriction du résultat"
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr "Un criterion (critère de recherche) est une instance de l'interface <literal>org.hibernate.criterion.Criterion</literal>. La classe <literal>org.hibernate.criterion.Restrictions</literal> définit des méthodes pour obtenir des types de <literal>Criterion</literal> pré-définis."
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr "Les restrictions peuvent être goupées de manière logique."
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr "Il y a plusieurs types de criterion pré-définis (sous classes de <literal>Restriction</literal>), mais l'une d'entre elle particulièrement utile vous permet de spécifier directement du SQL."
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sql(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr "La zone <literal>{alias}</literal> sera remplacée par l'alias de colonne de l'entité que l'on souhaite intérroger."
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr "Une autre approche pour obtenir un criterion est de le récupérer d'une instance de <literal>Property</literal>. Vous pouvez créer une <literal>Property</literal> en appelant <literal>Property.forName()</literal>."
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr "Trier les résultats"
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr "Vous pouvez trier les résultats en utilisant <literal>org.hibernate.criterion.Order</literal>."
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:81
+msgid "Associations"
+msgstr "Associations"
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr "Vous pouvez facilement spécifier des contraintes sur des entités liées, par des associations en utilisant <literal>createCriteria()</literal>."
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .list();]]>"
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr "Notez que la seconde <literal>createCriteria()</literal> retourne une nouvelle instance de <literal>Criteria</literal>, qui se rapporte aux éléments de la collection <literal>kittens</literal>."
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr "La forme alternative suivante est utile dans certains cas."
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr "(<literal>createAlias()</literal> ne crée pas de nouvelle instance de <literal>Criteria</literal>.)"
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr "Notez que les collections kittens contenues dans les instances de <literal>Cat</literal> retournées par les deux précédentes requêtes ne sont <emphasis>pas</emphasis> pré-filtrées par les critères ! Si vous souhaitez récupérer uniquement les kittens qui correspondent à la criteria, vous devez utiliser <literal>ResultTransformer</literal>."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr "Peuplement d'associations de manière dynamique"
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr "Vous pouvez spéficier au moment de l'exécution le peuplement d'une association en utilisant <literal>setFetchMode()</literal> (c'est-à -dire le chargement de celle-ci). Cela permet de surcharger les valeurs \"lazy\" et \"outer-join\" du mapping."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "Cette requête recherchera <literal>mate</literal> et <literal>kittens</literal> via les jointures externes. Voir <xref linkend=\"performance-fetching\"/> pour plus d'informations."
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr "Requêtes par l'exemple"
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr "La classe <literal>org.hibernate.criterion.Example</literal> vous permet de construire un critère suivant une instance d'objet donnée."
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr "Les propriétés de type version, identifiant et association sont ignorées. Par défaut, les valeurs null sont exclues."
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr "Vous pouvez ajuster la stratégie d'utilisation de valeurs de l'<literal>Exemple</literal>."
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr "Vous pouvez utiliser les \"exemples\" pour des critères sur les objets associés."
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr "Projections, agrégation et regroupement"
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr "La classe <literal>org.hibernate.criterion.Projections</literal> est une fabrique d'instances de <literal>Projection</literal>. Nous appliquons une projection sur une requête en appelant <literal>setProjection()</literal>."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr "Il n'y a pas besoin de \"group by\" explicite dans une requête par critère. Certains types de projection sont définis pour être des <emphasis>projections de regroupement</emphasis>, lesquels apparaissent aussi dans la clause <literal>group by</literal> SQL."
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr "Un alias peut optionnellement être assigné à une projection, ainsi la valeur projetée peut être référencée dans des restrictions ou des tris. Voici deux façons différentes de faire ça :"
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr "Les méthodes <literal>alias()</literal> et <literal>as()</literal> enveloppe simplement une instance de projection dans une autre instance (aliasée) de <literal>Projection</literal>. Comme un raccourci, vous pouvez assignez un alias lorsque vous ajoutez la projection à la liste de projections :"
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr "Vous pouvez aussi utiliser <literal>Property.forName()</literal> pour formuler des projections :"
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr "Requêtes et sous-requêtes détachées"
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr "La classe <literal>DetachedCriteria</literal> vous laisse créer une requête en dehors de la portée de la session, et puis l'exécuter plus tard en utilisant n'importe quelle <literal>Session</literal> arbitraire."
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ "\n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr "Une <literal>DetachedCriteria</literal> peut aussi être utilisée pour exprimer une sous-requête. Des instances de criterion impliquant des sous-requêtes peuvent être obtenues via <literal>Subqueries</literal> ou <literal>Property</literal>."
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr "Même des requêtes corrélées sont possibles :"
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr "Requêtes par identifiant naturel"
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr "Pour la plupart des requêtes, incluant les requêtes par critère, le cache de requêtes n'est pas très efficace, parce que l'invalidation du cache de requêtes arrive trop souvent. Cependant, il y a une sorte spéciale de requête où nous pouvons optimiser l'algorithme d'invalidation du cache : les recherches sur une clef naturelle constante. Dans certaines applications, cette sorte de requête se produit fréquemment. L'API de critère fournit une provision spéciale pour ce cas d'utilisation."
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr "D'abord vous devriez mapper la clef naturelle de votre entité en utilisant <literal><natural-id></literal>, et activer l'utilisation du cache de second niveau."
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr "Notez que cette fonctionnalité n'est pas prévue pour l'utilisation avec des entités avec des clefs naturelles <emphasis>mutables</emphasis>."
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr "Ensuite, activez le cache de requête d'Hibernate."
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr "Maintenant <literal>Restrictions.naturalId()</literal> nous permet de rendre l'utilisation de l'algorithme de cache plus efficace."
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\")\n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1512 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr "HQL: Langage de requêtage d'Hibernate"
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr "Hibernate fourni un langage d'interrogation extrêmement puissant qui ressemble (et c'est voulu) au SQL. Mais ne soyez pas distraits par la syntaxe ; HQL est totalement orienté objet, comprenant des notions d'héritage, de polymorphisme et d'association."
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr "Sensibilité à la casse"
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr "Les requêtes sont insensibles à la casse, à l'exception des noms des classes Java et des propriétés. Ainsi, <literal>SeLeCT</literal> est identique à <literal>sELEct</literal> et à <literal>SELECT</literal> mais <literal>net.sf.hibernate.eg.FOO</literal> n'est pas identique <literal>net.sf.hibernate.eg.Foo</literal> et <literal>foo.barSet</literal> n'est pas identique à <literal>foo.BARSET</literal>."
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr "Ce guide utilise les mots clés HQL en minuscule. Certains utilisateurs trouvent les requêtes écrites avec les mots clés en majuscule plus lisibles, mais nous trouvons cette convention pénible lorsqu'elle est lue dans du code Java."
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr "La clause from"
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr "La requête Hibernate la plus simple est de la forme :"
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr "<![CDATA[from eg.Cat]]>"
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr "qui retourne simplement toutes les instances de la classe <literal>eg.Cat</literal>. Nous n'avons pas besoin d'habitude de qualifier le nom de la classe, puisque <literal>auto-import</literal> est la valeur par défaut. Donc nous écrivons presque toujours :"
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr "<![CDATA[from Cat]]>"
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr "La plupart du temps, vous devrez assigner un <emphasis>alias</emphasis> puisque vous voudrez faire référence à <literal>Cat</literal> dans d'autres parties de la requête."
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr "Cette requête assigne l'alias <literal>cat</literal> à l'instance <literal>Cat</literal>, nous pouvons donc utiliser cet alias ailleurs dans la requête. Le mot clé <literal>as</literal> est optionnel ; nous aurions pu écrire :"
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr "<![CDATA[from Cat cat]]>"
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr "Plusieurs classes peuvent apparaître, ce qui conduira à un produit cartésien (encore appelé jointures croisées)."
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr "<![CDATA[from Formula, Parameter]]>"
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr "<![CDATA[from Formula as form, Parameter as param]]>"
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr "C'est une bonne pratique que de nommer les alias dans les requêtes en utilisant l'initiale en miniscule, ce qui a le mérite d'être en phase avec les standards de nommage Java pour les variables locales (<literal>domesticCat</literal>)."
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr "Associations et jointures"
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr "On peut aussi assigner des alias à des entités associées, ou même aux éléments d'une collection de valeurs, en utilisant un <literal>join</literal> (jointure)."
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr "<![CDATA[from Formula form full join form.parameter param]]>"
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr "Les types de jointures supportées sont celles de ANSI SQL"
+
+#: index.docbook:103
+msgid "inner join"
+msgstr "<literal>inner join</literal> (jointure fermée)"
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr "<literal>left outer join</literal> (jointure ouverte par la gauche)"
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr "<literal>right outer join</literal> (jointure ouverte par la droite)"
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr "<literal>full join</literal> (jointure ouverte totalement - généralement inutile)"
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr "Les constructions des jointures <literal>inner join</literal>, <literal>left outer join</literal> et <literal>right outer join</literal> peuvent être abbrégées."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr "Nous pouvons soumettre des conditions de jointure supplémentaires en utilisant le mot-clef HQL <literal>with</literal>."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "Par ailleurs, une jointure \"fetchée\" (rapportée) permet d'initialiser les associations ou collections de valeurs en même temps que leur objet parent, le tout n'utilisant qu'un seul Select. Ceci est particulièrement utile dans le cas des collections. Ce système permet de surcharger les déclarations \"lazy\" et \"outer-join\" des fichiers de mapping pour les associations et collections. Voir <xref linkend=\"performance-fetching\"/> pour plus d'informations."
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr "Une jointure \"fetchée\" (rapportée) n'a généralement pas besoin de se voir assigner un alias puisque les objets associés n'ont pas à être utilisés dans les autres clauses. Notez aussi que les objets associés ne sont pas retournés directement dans le résultat de la requête mais l'on peut y accéder via l'objet parent. La seule raison pour laquelle nous pourrions avoir besoin d'un alias est si nous récupérions récursivement une collection supplémentaire :"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr "Notez que la construction de <literal>fetch</literal> ne peut pas être utilisée dans les requêtes appelées par <literal>scroll()</literal> ou <literal>iterate()</literal>. <literal>fetch</literal> ne devrait pas non plus être utilisé avec <literal>setMaxResults()</literal> ou <literal>setFirstResult()</literal>. <literal>fetch</literal> ne peut pas non plus être utilisé avec une condition <literal>with</literal> ad hoc. Il est possible de créer un produit cartésien par jointure en récupérant plus d'une collection dans une requête, donc faites attention dans ce cas. Récupérer par jointure de multiples collections donne aussi parfois des résultats inattendus pour des mappings de bag, donc soyez prudent lorsque vous formulez vos requêtes dans de tels cas. Finalement, notez que <literal>full join fetch</literal> et <literal>right join fetch</literal> ne sont pas utiles en général."
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr "Si vous utilisez un chargement retardé pour les propriétés (avec une instrumentation par bytecode), il est possible de forcer Hibernate à récupérer les propriétés non encore chargées immédiatement (dans la première requête) en utilisant <literal>fetch all properties</literal>."
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr "<![CDATA[from Document fetch all properties order by name]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr "Formes de syntaxes pour les jointures"
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr "HQL supporte deux formes pour joindre les associations: <literal>implicite</literal> et <literal>explicite</literal>."
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr "Les requêtes présentes dans la section précédente utilisent la forme <literal>explicite</literal> où le mode clé join est explicitement utilisé dans la clause from. C'est la forme recommandée."
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr "La forme <literal>implicite</literal> n'utilise pas le mot clé join. A la place, les associations sont \"déréférencées\" en utilisant le notation '.'. Ces jointures peuvent apparaitre dans toutes les clauses. Les jointures <literal>implicites</literal> résultent en des inner join dans le SQL généré."
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr "La clause select"
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr "La clause <literal>select</literal> sélectionne les objets et propriétés qui doivent être retournés dans le résultat de la requête. Soit :"
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr "La requête recherchera les <literal>mate</literal>s liés aux <literal>Cat</literal>s. Vous pouvez explimer la requête d'une manière plus compacte :"
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr "<![CDATA[select cat.mate from Cat cat]]>"
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr "Les requêtes peuvent retourner des propriétés de n'importe quel type, même celles de type composant (component) :"
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr "Les requêtes peuvent retourner plusieurs objets et/ou propriétés sous la forme d'un tableau du type <literal>Object[]</literal>,"
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr "ou sous la forme d'une <literal>List</literal>,"
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr "ou sous la forme d'un objet Java typé,"
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr "à condition que la classe <literal>Family</literal> possède le constructeur approprié."
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr "Vous pouvez assigner des alias aux expressions sélectionnées en utilisant <literal>as</literal> :"
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr "C'est surtout utile lorsque c'est utilisé avec <literal>select new map</literal> :"
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr "Cette requête retourne une <literal>Map</literal> à partir des alias vers les valeurs sélectionnées."
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr "Fonctions d'aggrégation"
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr "Les requêtes HQL peuvent aussi retourner le résultat de fonctions d'aggrégation sur les propriétés :"
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr "Les fonctions supportées sont"
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr "avg(...), sum(...), min(...), max(...)"
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr "count(*)"
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr "count(...), count(distinct ...), count(all...)"
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr "Vous pouvez utiliser des opérateurs arithmétiques, la concaténation, et des fonctions SQL reconnues dans la clause select :"
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr "Les mots clé <literal>distinct</literal> et <literal>all</literal> peuvent être utilisés et ont la même signification qu'en SQL."
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr "Requêtes polymorphiques"
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr "Une requête comme:"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr "retourne non seuleument les instances de <literal>Cat</literal>, mais aussi celles des sous classes comme <literal>DomesticCat</literal>. Les requêtes Hibernate peuvent nommer n'importe quelle classe ou interface Java dans la clause <literal>from</literal>. La requête retournera les instances de toutes les classes persistantes qui étendent cette classe ou implémente cette interface. La requête suivante retournera tous les objets persistants :"
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr "<![CDATA[from java.lang.Object o]]>"
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr "L'interface <literal>Named</literal> peut être implémentée par plusieurs classes persistantes :"
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr "Notez que ces deux dernières requêtes nécessitent plus d'un <literal>SELECT</literal> SQL. Ce qui signifie que la clause <literal>order by</literal> ne trie pas correctement la totalité des résultats (cela signifie aussi que vous ne pouvez exécuter ces requêtes en appelant <literal>Query.scroll()</literal>)."
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr "La clause <literal>where</literal> vous permet de réduire la liste des instances retournées. Si aucun alias n'existe, vous pouvez vous référer aux propriétés par leur nom :"
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr "<![CDATA[from Cat where name='Fritz']]>"
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr "S'il y a un alias, utilisez un nom de propriété qualifié :"
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr "retourne les instances de <literal>Cat</literal> dont name est égale à 'Fritz'."
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr "retournera les instances de <literal>Foo</literal> pour lesquelles il existe une instance de <literal>bar</literal> avec la propriété <literal>date</literal> est égale à la propriété <literal>startDate</literal> de <literal>Foo</literal>. Les expressions utilisant la navigation rendent la clause <literal>where</literal> extrêmement puissante. Soit :"
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr "Cette requête se traduit en SQL par une jointure interne à une table. Si vous souhaitez écrire quelque chose comme :"
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr "vous finiriez avec une requête qui nécessiterait quatre jointures en SQL."
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr "L'opérateur <literal>=</literal> peut être utilisé pour comparer aussi bien des propriétés que des instances :"
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr "La propriété spéciale (en minuscule) <literal>id</literal> peut être utilisée pour faire référence à l'identifiant d'un objet (vous pouvez aussi utiliser le nom de cette propriété)."
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr "La seconde requête est particulièrement efficace. Aucune jointure n'est nécessaire !"
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr "Les propriétés d'un identifiant composé peuvent aussi être utilisées. Supposez que <literal>Person</literal> ait un identifiant composé de <literal>country</literal> et <literal>medicareNumber</literal>."
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr "Une fois de plus, la seconde requête ne nécessite pas de jointure."
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr "De même, la propriété spéciale <literal>class</literal> interroge la valeur discriminante d'une instance dans le cas d'une persistance polymorphique. Le nom d'une classe Java incorporée dans la clause where sera traduite par sa valeur discriminante."
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr "Vous pouvez aussi spécifier les propriétés des composants ou types utilisateurs composés (components, composite user types etc). N'essayez jamais d'utiliser un expression de navigation qui se terminerait par une propriété de type composant (qui est différent d'une propriété d'un composant). Par exemple, si <literal>store.owner</literal> est une entité avec un composant <literal>address</literal>"
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr ""
+ "<![CDATA[store.owner.address.city // okay\n"
+ "store.owner.address // error!]]>"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr "Un type \"any\" possède les propriétés spéciales <literal>id</literal> et <literal>class</literal>, qui nous permettent d'exprimer une jointure de la manière suivante (où <literal>AuditLog.item</literal> est une propriété mappée avec <literal><any></literal>)."
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr "Dans la requête précédente, notez que <literal>log.item.class</literal> et <literal>payment.class</literal> feraient référence à des valeurs de colonnes de la base de données complètement différentes."
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr "Expressions"
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr "Les expressions permises dans la clause <literal>where</literal> incluent la plupart des choses que vous pouvez utiliser en SQL :"
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr "opérateurs mathématiques <literal>+, -, *, /</literal>"
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr "opérateur de comparaison binaire <literal>=, >=, <=, <>, !=, like</literal>"
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr "opérateurs logiques <literal>and, or, not</literal>"
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr "Parenthèses <literal>( )</literal>, indiquant un regroupement"
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr "concatenation de chaîne de caractères <literal>...||...</literal> ou <literal>concat(...,...)</literal>"
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr "N'importe quel fonction ou opérateur défini par EJB-QL 3.0 : <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr "<literal>coalesce()</literal> et <literal>nullif()</literal>"
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr "<literal>str()</literal> pour convertir des valeurs numériques ou temporelles vers une chaîne de caractères lisible"
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr "<literal>cast(... as ...)</literal>, où le second argument est le nom d'un type Hibernate, et <literal>extract(... from ...)</literal> si le <literal>cast()</literal> ANSI et <literal>extract()</literal> sont supportés par la base de données sous-jacente"
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr "La fonction HQL <literal>index()</literal>, qui s'applique aux alias d'une collection indexée jointe"
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr "Les fonctions HQL qui s'appliquent expressions représentant des collections : <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, ainsi que les fonctions spéciales <literal>elements()</literal> et <literal>indices</literal> qui peuvent être quantifiées en utilisant <literal>some, all, exists, any, in</literal>."
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr "N'importe quelle fonction scalaire supportée par la base de données comme <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr "Les paramètres positionnels de JDBC <literal>?</literal>"
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr "paramètres nommés <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr "littéral SQL <literal>'foo'</literal>, <literal>69</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr "Constantes Java <literal>public static final</literal> <literal>eg.Color.TABBY</literal>"
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr "<literal>in</literal> et <literal>between</literal> peuvent être utilisés comme suit :"
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr "et la forme négative peut être écrite"
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr "De même, <literal>is null</literal> et <literal>is not null</literal> peuvent être utilisés pour tester les valeurs nulle."
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "Les booléens peuvent être facilement utilisés en déclarant les substitutions de requêtes dans la configuration Hibernate :"
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr "Ce qui remplacera les mots clés <literal>true</literal> et <literal>false</literal> par <literal>1</literal> et <literal>0</literal> dans la traduction SQL du HQL suivant :"
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from Cat cat where cat.alive = true]]>"
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr "Vous pouvez tester la taille d'une collection par la propriété spéciale <literal>size</literal>, ou la fonction spéciale <literal>size()</literal>."
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr "Pour les collections indexées, vous pouvez faire référence aux indices minimum et maximum en utilisant les fonctions <literal>minindex</literal> and <literal>maxindex</literal>. De manière similaire, vous pouvez faire référence aux éléments minimum et maximum d'une collection de type basiques en utilisant les fonctions <literal>minelement</literal> et <literal>maxelement</literal>."
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current date]]>"
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr "Les fonctions SQL <literal>any, some, all, exists, in</literal> supportent que leur soient passées l'élément, l'index d'une collection (fonctions <literal>elements</literal> et <literal>indices</literal>) ou le résultat d'une sous requête (voir ci dessous)."
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr "Notez que l'écriture de - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - peuvent seulement être utilisée dans la clause where dans Hibernate3."
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr "Les éléments de collections indexées (arrays, lists, maps) peuvent être référencés via index (dans une clause where seulement) :"
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr "L'expression entre <literal>[]</literal> peut même être une expression arithmétique."
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr "HQL propose aussi une fonction <literal>index()</literal> interne, pour les éléments d'une association one-to-many ou d'une collections de valeurs."
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr "Les fonctions SQL scalaires supportées par la base de données utilisée peuvent être utilisées"
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr "Si vous n'êtes pas encore convaincu par tout cela, imaginez la taille et l'illisibilité qui caractériseraient la transformation SQL de la requête HQL suivante :"
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr "<emphasis>Un indice :</emphasis> cela donnerait quelque chose comme"
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr "La clause order by"
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr "La liste retounée par la requête peut être triée par n'importe quelle propriété de la classe ou du composant retourné :"
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr "Le mot optionnel <literal>asc</literal> ou <literal>desc</literal> indique respectivement si le tri doit être croissant ou décroissant."
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr "La clause group by"
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr "Si la requête retourne des valeurs aggrégées, celles ci peuvent être groupées par propriété ou composant :"
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr "Une clause <literal>having</literal> est aussi permise."
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr "Les fonctions SQL et les fonctions d'aggrégations sont permises dans les clauses <literal>having</literal> et <literal>order by</literal>, si elles sont supportées par la base de données (ce que ne fait pas MySQL par exemple)."
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr "Notez que ni la clause <literal>group by</literal> ni la clause <literal>order by</literal> ne peuvent contenir d'expressions arithmétiques."
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr "Sous-requêtes"
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr "Pour les bases de données le supportant, Hibernate supporte les sous requêtes dans les requêtes. Une sous requête doit être entre parenthèses (souvent pour un appel à une fonction d'agrégation SQL) Même les sous requêtes corrélées (celles qui font référence à un alias de la requête principale) sont supportées."
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr "Notez que les sous-requêtes HQL peuvent arriver seulememnt dans les clauses select ou where."
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "Pour des sous-requêtes avec plus d'une expression dans le select, vous pouvez utiliser un constructeur de tuples :"
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "Notez que sur certaines bases de données (mais par Oracle ou HSQL), vous pouvez utiliser des constructeurs de tuples dans d'autres contextes, par exemple lors du requêtage de composants ou de types utilisateur composites :"
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr "<![CDATA[from Person where name = ('Gavin', 'A', 'King')]]>"
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr "Ce qui est équivalent à la forme plus verbeuse suivante :"
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr "<![CDATA[from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')]]>"
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr "Il y a deux bonnes raisons que vous ne puissiez ne pas vouloir faire cette sorte de choses : d'abord, ce n'est pas complètement portable entre les plateformes de base de données ; deuxièmement, la requête est maintenant dépendante de l'ordre des propriétés dans le document de mapping."
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr "Exemples HQL"
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr "Les requêtes Hibernate peuvent être relativement puissantes et complexes. En fait, la puissance du langage de requêtage est l'un des avantages principaux d'Hibernate. Voici quelques exemples très similaires aux requêtes que nous avons utilisées lors d'un récent projet. Notez que la plupart des requêtes que vous écrirez seront plus simples que les exemples suivantes !"
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr "La requête suivante retourne l'id de commande (order), le nombre d'articles (items) et la valeur totale de la commande (order) pour toutes les commandes non payées d'un client (customer) particulier pour un total minimum donné, le tout trié par la valeur totale. La requête SQL générée sur les tables <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> et <literal>PRICE</literal> est composée de quatre jointures interne ainsi que d'une sous-requête (non corrélée)."
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr "Quel monstre ! En principe, nous ne sommes pas très fan des sous-requêtes, la requête ressemblait donc plutôt à cela :"
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr "La requête suivante compte le nombre de paiements (payments) pour chaque status, en excluant les paiements dans le status <literal>AWAITING_APPROVAL</literal> où le changement de status le plus récent à été fait par l'utilisateur courant. En SQL, cette requête effectue deux jointures internes et des sous requêtes corrélées sur les tables <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> et <literal>PAYMENT_STATUS_CHANGE</literal>."
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr "Si nous avions mappé la collection <literal>statusChanges</literal> comme une liste, au lieu d'un ensemble, la requête aurait été plus facile à écrire."
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "La requête qui suit utilise la fonction de MS SQL <literal>isNull()</literal> pour retourner tous les comptes (accounts) et paiements (payments) impayés pour l'organisation à laquelle l'uilisateur (user) courant appartient. Elle est traduite en SQL par trois jointures internes, une jointure externe ainsi qu'une sous requête sur les tables <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> et <literal>ORG_USER</literal>."
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "Pour d'autres base de données, nous aurions dû faire sans la sous-requête (corrélée)."
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr "Mise à jour et suppression"
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr "HQL supporte maintenant les expressions <literal>update</literal>, <literal>delete</literal> et <literal>insert ... select ...</literal>. Voir <xref linkend=\"batch-direct\"/> pour les détails."
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr "Trucs & Astuces"
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr "Vous pouvez compter le nombre de résultats d'une requête sans les retourner :"
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr "Pour trier les résultats par la taille d'une collection, utilisez la requête suivante :"
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr "Si votre base de données supporte les sous-requêtes, vous pouvez placer des conditions sur la taille de la sélection dans la clause where de votre requête:"
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr "Si votre base de données ne supporte pas les sous-requêtes, utilisez la requête suivante :"
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr "Cette solution ne peut pas retourner un <literal>User</literal> avec zéro message à cause de la jointure interne, la forme suivante peut donc être utile :"
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr "Les propriétés d'un JavaBean peuvent être injectées dans les paramètres nommés d'un requête :"
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr "Les collections sont paginables via l'utilisation de l'interface <literal>Query</literal> avec un filtre :"
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr "Les éléments d'une collection peuvent être triés ou groupés en utilisant un filtre de requête :"
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr "Vous pouvez récupérer la taille d'une collection sans l'initialiser :"
+
+#: index.docbook:985
+msgid "Components"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr ""
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr ""
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr ""
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr ""
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr ""
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr ""
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr ""
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr ""
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr ""
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1003 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr "SQL natif"
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr "Vous pouvez aussi écrire vos requêtes dans le dialecte SQL natif de votre base de données. Ceci est utile si vous souhaitez utiliser les fonctionnalités spécifiques de votre base de données comme le mot clé <literal>CONNECT</literal> d'Oracle. Cette fonctionnalité offre par ailleurs un moyen de migration plus propre et doux d'une application basée sur SQL/JDBC vers une application Hibernate."
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr "Hibernate3 vous permet de spécifier du SQL écrit à la main (incluant les procédures stockées) pour toutes les opérations de création, mise à jour, suppression et chargement."
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr "Utiliser une <literal>SQLQuery</literal>"
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr "L'exécution des requêtes en SQL natif est contrôlée par l'interface <literal>SQLQuery</literal>, laquelle est obtenue en appelant <literal>Session.createSQLQuery()</literal>. Dans des cas extrêmement simples, nous pouvons utiliser la forme suivante :"
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr ""
+ "List cats = sess.createSQLQuery(\"select * from cats\")\n"
+ " .addEntity(Cat.class)\n"
+ " .list();"
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr "Cette requête a spécifié :"
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr "la requête SQL"
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr "l'entité retournée par la requête"
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr "Ici, les noms de colonne des résultats sont supposés être les mêmes que les noms de colonne spécifiés dans le document de mapping. Cela peut être problématique pour des requêtes SQL qui joignent de multiple tables, puisque les mêmes noms de colonne peuvent apparaître dans plus d'une table. La forme suivante n'est pas vulnérable à la duplication des noms de colonne :"
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr ""
+ "List cats = sess.createSQLQuery(\"select {cat.*} from cats cat\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .list();"
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr "Cette requête a spécifié :"
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr "la requête SQL, avec un paramètre fictif pour Hibernate pour injecter les alias de colonne"
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr "l'entité retournée par la requête, et son alias de table SQL"
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr "La méthode <literal>addEntity()</literal> associe l'alias de la table SQL avec la classe de l'entité retournée, et détermine la forme de l'ensemble des résultats de la requête."
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr "La méthode <literal>addJoin()</literal> peut être utilisée pour charger des associations vers d'autres entités et collections."
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr ""
+ "List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"kitten\", \"cat.kittens\")\n"
+ " .list();"
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr "Une requête SQL native pourrait retourner une simple valeur scalaire ou une combinaison de scalaires et d'entités."
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr ""
+ "Double max = (Double) sess.createSQLQuery(\"select max(cat.weight) as maxWeight from cats cat\")\n"
+ " .addScalar(\"maxWeight\", Hibernate.DOUBLE);\n"
+ " .uniqueResult();"
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr "Vous pouvez alternativement décrire les informations de mapping des résultats dans vos fichiers hbm et les utiliser pour vos requêtes."
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr ""
+ "List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();"
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr "Alias et références de propriété"
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr ""
+ "String sql = \"select cat.originalId as {cat.id}, \" +\n"
+ " \"cat.mateid as {cat.mate}, cat.sex as {cat.sex}, \" +\n"
+ " \"cat.weight*10 as {cat.weight}, cat.name as {cat.name} \" +\n"
+ " \"from cat_log cat where {cat.mate} = :catId\"\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .setLong(\"catId\", catId)\n"
+ " .list();"
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr "<emphasis>À noter :</emphasis> si vous listez chaque propriété explicitement, vous devez inclure toutes les propriétés de la classe <emphasis>et ses sous-classes</emphasis> !"
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr "La table suivante montre les différentes possibilités d'utilisation de l'injection d'alias. À noter : les noms des alias dans le résultat sont des exemples, chaque alias aura un nom unique et probablement différent lors de l'utilisation."
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr "Noms d'injection d'alias"
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr "Description"
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr "Syntaxe"
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr "Exemple"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr "Une simple propriété"
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr "{[aliasname].[propertyname]}"
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr "A_NAME as {item.name}"
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr "Une propriété composée"
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr "{[aliasname].[componentname].[propertyname]}"
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr "Discriminant d'une entité"
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr "{[aliasname].class}"
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr "DISC as {item.class}"
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr "Toutes les propriétés d'une entité"
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr "{[aliasname].*}"
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr "Une clef de collection"
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr "{[aliasname].key}"
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr "ORGID as {coll.key}"
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr "L'identifiant d'une collection"
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr "{[aliasname].id}"
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr "EMPID as {coll.id}"
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr "L'élément d'une collection"
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr "{[aliasname].element}"
+
+#: index.docbook:219
+msgid "Description"
+msgstr "XID as {coll.element}"
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr "Propriété de l'élément dans la collection"
+
+#: index.docbook:223
+msgid "Example"
+msgstr "{[aliasname].element.[propertyname]}"
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr "NAME as {coll.element.name}"
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr "Toutes les propriétés de l'élément dans la collection"
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr "{[aliasname].element.*}"
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr "{coll.element.*}"
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr "Toutes les propriétés de la collection"
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr "{[aliasname].*}"
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr "{coll.*}"
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr "Requêtes SQL nommées"
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr "Les requêtes SQL nommées peuvent être définies dans le document de mapping et appelées exactement de la même manière qu'un requête HQL nommée. Dans ce cas, nous <emphasis>n'avons pas besoin</emphasis> d'appeler <literal>addEntity()</literal>."
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr ""
+ "<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>"
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr ""
+ "List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();"
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr "Les éléments <literal><return-join></literal> et <literal><load-collection></literal> sont respectivement utilisés pour lier des associations et définir des requêtes qui initialisent des collections."
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr ""
+ "<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>"
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr "Une requête SQL nommée peut retourner une valeur scalaire. Vous devez spécifier l'alias de colonne et le type Hibernate utilisant l'élément <literal><return-scalar></literal> :"
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr ""
+ "<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>"
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr "Vous pouvez externaliser les informations de mapping des résultats dans un élément <literal><resultset></literal> pour soit les réutiliser dans différentes requêtes nommées, soit à travers l'API <literal>setResultSetMapping()</literal>."
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr ""
+ "<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>"
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr "Utilisation de return-property pour spécifier explicitement les noms des colonnes/alias"
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr "Avec <literal><return-property></literal> vous pouvez explicitement dire à Hibernate quels alias de colonne utiliser, plutot que d'employer la syntaxe <literal>{}</literal> pour laisser Hibernate injecter ses propres alias."
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr ""
+ "<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>"
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr "<literal><return-property></literal> fonctionne aussi avec de multiple colonnes. Cela résout une limitation de la syntaxe <literal>{}</literal> qui ne peut pas permettre une bonne granularité des propriétés multi-colonnes."
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr ""
+ "<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>"
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr "Notez que dans cet exemple nous avons utilisé <literal><return-property></literal> en combinaison avec la syntaxe <literal>{}</literal> pour l'injection. Cela autorise les utilisateurs à choisir comment ils veulent référencer les colonnes et les propriétés."
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr "Si votre mapping a un discriminant vous devez utiliser <literal><return-discriminator></literal> pour spécifier la colonne discriminante."
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr "Utilisation de procédures stockées pour les requêtes"
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr "Hibernate 3 introduit le support des requêtes via procédures stockées et les fonctions. La documentation suivante est valable pour les deux. Les procédures stockées/fonctions doivent retourner l'ensemble de résultats en tant que premier paramètre sortant (NdT: \"out-parameter\") pour être capable de fonctionner avec Hibernate. Un exemple d'une telle procédure stockée en Oracle 9 et version supérieure :"
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr ""
+ "CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;"
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr "Pour utiliser cette requête dans Hibernate vous avez besoin de la mapper via une requête nommée."
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr "Notez que les procédures stockées retournent, pour le moment, seulement des scalaires et des entités. <literal><return-join></literal> et <literal><load-collection></literal> ne sont pas supportés."
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr "Règles/limitations lors de l'utilisation des procédures stockées"
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr "Pur utiliser des procédures stockées avec Hibernate, les procédures doivent suivre certaines règles. Si elles ne suivent pas ces règles, elles ne sont pas utilisables avec Hibernate. Si vous voulez encore utiliser ces procédures vous devez les exécuter via <literal>session.connection()</literal>. Les règles sont différentes pour chaque base de données, puisque les vendeurs de base de données ont des sémantiques/syntaxes différentes pour les procédures stockées."
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr "Les requêtes de procédures stockées ne peuvent pas être paginées avec <literal>setFirstResult()/setMaxResults()</literal>."
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr "Pour Sybase ou MS SQL server les règles suivantes s'appliquent :"
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr "La procédure doit retourner un ensemble de résultats. Notez que comme ces serveurs peuvent retourner de multiples ensembles de résultats et mettre à jour des compteurs, Hibernate itérera les résultats et prendra le premier résultat qui est un ensemble de résultat comme valeur de retour. Tout le reste sera ignoré."
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr "Si vous pouvez activer <literal>SET NOCOUNT ON</literal> dans votre procédure, elle sera probablement plus efficace, mais ce n'est pas une obligation."
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr "SQL personnalisé pour créer, mettre à jour et effacer"
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr "Hibernate3 peut utiliser des expression SQL personnalisées pour des opérations de création, de mise à jour, et de suppression. Les objets persistants les classes et les collections dans Hibernate contiennent déjà un ensemble de chaînes de caractères générées lors de la configuration (insertsql, deletesql, updatesql, etc). Les tages de mapping <literal><sql-insert></literal>, <literal><sql-delete></literal>, et <literal><sql-update></literal> surchargent ces chaînes de caractères :"
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr ""
+ "<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>"
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr "Le SQL est directement exécuté dans votre base de données, donc vous êtes libre d'utiliser le dialecte que vous souhaitez. Cela réduira bien sûr la portabilité de votre mapping si vous utilisez du SQL spécifique à votre base de données."
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr "Les procédures stockées sont supportées si l'attribut <literal>callable</literal> est paramétré :"
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr ""
+ "<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>"
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr "L'ordre des paramètres positionnels est actuellement vital, car ils doivent être dans la même séquence qu'Hibernate les attend."
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr "Vous pouvez voir l'ordre attendu en activant les journaux de debug pour le niveau <literal>org.hibernate.persister.entity</literal> level. Avec ce niveau activé, Hibernate imprimera le SQL statique qui est utilisé pour créer, mettre à jour, supprimer, etc. des entités. (Pour voir la séquence attendue, rappelez-vous de ne pas inclure votre SQL personnalisé dans les fichiers de mapping de manière à surcharger le SQL statique généré par Hibernate.)"
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr "Les procédures stockées sont dans la plupart des cas (lire : il vaut mieux le faire) requises pour retourner le nombre de lignes insérées/mises à jour/supprimées, puisque Hibernate fait quelques vérifications de succès lors de l'exécution de l'expression. Hibernate inscrit toujours la première expression comme un paramètre de sortie numérique pour les opérations CUD :"
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;"
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr "SQL personnalisé pour le chargement"
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr "Vous pouvez aussi déclarer vos propres requêtes SQL (ou HQL) pour le chargement d'entité :"
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr ""
+ "<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>"
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr "Ceci est juste une déclaration de requête nommée, comme vu plus tôt. Vous pouvez référencer cette requête nommée dans un mapping de classe :"
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr ""
+ "<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>"
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr "Ceci fonctionne même avec des procédures stockées."
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr "Vous pouvez même définir une requête pour le chargement d'une collection :"
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr ""
+ "<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>"
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+ "<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>"
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr "Vous pourriez même définir un chargeur d'entité qui charge une collection par jointure :"
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>"
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr ""
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr ""
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr ""
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr ""
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr ""
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr ""
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr ""
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr ""
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr ""
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr ""
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr ""
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr ""
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr ""
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr ""
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr ""
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr ""
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr ""
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr ""
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr ""
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr ""
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr ""
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr ""
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr ""
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr ""
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr ""
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr ""
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr ""
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,12 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1220 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr "Travailler avec des objets"
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr "Hibernate est une solution de mapping objet/relationnel complète qui ne masque pas seulement au développpeur les détails du système de gestion de base de données sous-jacent, mais offre aussi <emphasis>la gestion d'état</emphasis> des objets. C'est, contrairement à la gestion de <literal>statements</literal> SQL dans les couches de persistance habituelles JDBC/SQL, une vue orientée objet très naturelle de la persistance dans les applications Java."
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr "En d'autres mots, les développeurs d'applications Hibernate devrait toujours réfléchir à <emphasis>l'état</emphasis> de leurs objets, et pas nécessairement à l'exécution des expressions SQL. Cette part est prise en charge pas Hibernate et seulement importante pour les développeurs d'applications lors du réglage de la performance de leur système."
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr "États des objets Hibernate"
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr "Hibernate définit et comprend les états suivants :"
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr "<emphasis>Éphémère</emphasis> (NdT : transient) - un objet est éphémère s'il a juste été instancié en utilisant l'opérateur <literal>new</literal>. Il n'a aucune représentation persistante dans la base de données et aucune valeur d'identifiant n'a été assignée. Les instances éphémères seront détruites par le ramasse-miettes si l'application n'en conserve aucune référence. Utilisez la <literal>Session</literal> d'Hibernate pour rendre un objet persistant (et laisser Hibernate s'occuper des expressions SQL qui ont besoin d'être exécutées pour cette transistion)."
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr "<emphasis>Persistant</emphasis> - une instance persistante a une représentation dans la base de données et une valeur d'identifiant. Elle pourrait avoir juste été sauvegardée ou chargée, pourtant, elle est par définition dans la portée d'une <literal>Session</literal>. Hibernate détectera n'importe quels changements effectués sur un objet dans l'état persistant et synchronisera l'état avec la base de données lors de la fin l'unité de travail. Les développeurs n'exécutent pas d'expressions <literal>UPDATE</literal> ou <literal>DELETE</literal> manuelles lorsqu'un objet devrait être rendu éphémère."
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr "<emphasis>Détaché</emphasis> - une instance détachée est un objet qui a été persistant, mais dont sa <literal>Session</literal> a été fermée. La référence à l'objet est encore valide, bien sûr, et l'instance détachée pourrait même être modifiée dans cet état. Une instance détachée peut être réattachée à une nouvelle <literal>Session</literal> plus tard dans le temps, la rendant (et toutes les modifications avec) de nouveau persistante. Cette fonctionnalité rend possible un modèle de programmation pour de longues unités de travail qui requièrent un temps de réflexion de l'utilisateur. Nous les appelons des <emphasis>conversations</emphasis>, c'est-à -dire une unité de travail du point de vue de l'utilisateur."
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr "Nous alons maintenant dicuster des états et des transitions d'état (et des méthodes d'Hibernate qui déclenchent une transition) plus en détails."
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr "Rendre des objets persistants"
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr "Les instances nouvellement instanciées d'une classe persistante sont considérées <emphasis>éphémères</emphasis> par Hibernate. Nous pouvons rendre une instance éphémère <emphasis>persistante</emphasis> en l'associant avec une session :"
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr "Si <literal>Cat</literal> a un identifiant généré, l'identifiant est généré et assigné au <literal>cat</literal> lorsque <literal>save()</literal> est appelée. Si <literal>Cat</literal> a un identifiant <literal>assigned</literal>, ou une clef composée, l'identifiant devrait être assigné à l'instance de <literal>cat</literal> avant d'appeler <literal>save()</literal>. Vous pouvez aussi utiliser <literal>persist()</literal> à la place de<literal>save()</literal>, avec la sémantique définie plus tôt dans le brouillon d'EJB3."
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr "Alternativement, vous pouvez assigner l'identifiant en utilisant une version surchargée de <literal>save()</literal>."
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr "Si l'objet que vous rendez persistant a des objets associés (par exemple, la collection <literal>kittens</literal> dans l'exemple précédent), ces objets peuvent être rendus persistants dans n'importe quel ordre que vous souhaitez à moins que vous ayez une contrainte <literal>NOT NULL</literal> sur la colonne de la clef étrangère. Il n'y a jamais de risque de violer une contrainte de clef étrangère. Cependant, vous pourriez violer une contrainte <literal>NOT NULL</literal> si vous appeliez <literal>save()</literal> sur les objets dans le mauvais ordre."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr "Habituellement, vous ne vous préoccupez pas de ce détail, puisque vous utiliserez très probablement la fonctionnalité de <emphasis>persistance transitive</emphasis> d'Hibernate pour sauvegarder les objets associés automatiquement. Alors, même les violations de contrainte <literal>NOT NULL</literal> n'ont plus lieu - Hibernate prendra soin de tout. La persistance transitive est traitée plus loin dans ce chapitre."
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr "Chargement d'un objet"
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr "Les méthodes <literal>load()</literal> de <literal>Session</literal> vous donnent un moyen de récupérer une instance persistante si vous connaissez déjà son identifiant. <literal>load()</literal> prend un objet de classe et chargera l'état dans une instance nouvellement instanciée de cette classe, dans un état persistant."
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+ "<![CDATA[// vous avez besoin d'envelopper les identiants primitifs\n"
+ "long pkId = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( Cat.class, new Long(pkId) );]]>"
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr "Alternativement, vous pouvez charger un état dans une instance donnée :"
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr "Notez que <literal>load()</literal> lèvera une exception irrécupérable s'il n'y a pas de ligne correspondante dans la base de données. Si la classe est mappée avec un proxy, <literal>load()</literal> retourne juste un proxy non initialisé et n'accède en fait pas à la base de données jusqu'à ce que vous invoquiez une méthode du proxy. Ce comportement est très utile si vous souhaitez créer une association vers un objet sans réellement le charger à partir de la base de données. Cela permet aussi à de multiples instances d'être chargées comme un lot si <literal>batch-size</literal> est défini pour le mapping de la classe."
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr "Si vous n'êtes pas certain qu'une ligne correspondante existe, vous devriez utiliser la méthode <literal>get()</literal>, laquelle accède à la base de données immédiatement et retourne null s'il n'y a pas de ligne correspondante."
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr "Vous pouvez même charger un objet en employant un <literal>SELECT ... FOR UPDATE</literal> SQL, en utilisant un <literal>LockMode</literal>. Voir la documentation de l'API pour plus d'informations."
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr "Notez que n'importe quelles instances associées ou collections contenues <emphasis>ne sont pas</emphasis> sélectionnées par <literal>FOR UPDATE</literal>, à moins que vous ne décidiez de spécifier <literal>lock</literal> ou <literal>all</literal> en tant que style de cascade pour l'association."
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr "Il est possible de re-charger un objet et toutes ses collections à n'importe quel moment, en utilisant la méthode <literal>refresh()</literal>. C'est utile lorsque des \"triggers\" de base de données sont utilisés pour initiliser certains propriétés de l'objet."
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr "Une question importante apparaît généralement à ce point : combien (NdT : de données) Hibernate charge-t-il de la base de données et combient de <literal>SELECT</literal>s utilisera-t-il ? Cela dépent de la <emphasis>stratégie de récupération</emphasis> et cela est expliqué dans <xref linkend=\"performance-fetching\"/>."
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr "Requêtage"
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr "Si vous ne connaissez par les identifiants des objets que vous recherchez, vous avez besoin d'une requête. Hibernate supporte un langage de requêtes orientées objet facile à utiliser mais puissant. Pour la création de requêtes par programmation, Hibernate supporte une fonction de requêtage sophistiqué Criteria et Example (QBC et QBE). Vous pouvez aussi exprimez votre requête dans le SQL natif de votre base de données, avec un support optionnel d'Hibernate pour la conversion des ensembles de résultats en objets."
+
+#: index.docbook:219
+msgid "Querying"
+msgstr "Exécution de requêtes"
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr "Les requêtes HQL et SQL natives sont représentées avec une instance de <literal>org.hibernate.Query</literal>. L'interface offre des méthodes pour la liaison des paramètres, la gestion des ensembles de resultats, et pour l'exécution de la requête réelle. Vous obtenez toujours une <literal>Query</literal> en utilisant la <literal>Session</literal> courante :"
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr "Une requête est généralement exécutée en invoquant <literal>list()</literal>, le résultat de la requête sera chargée complètement dans une collection en mémoire. Les intances d'entités recupérées par une requête sont dans un état persistant. La méthode <literal>uniqueResult()</literal> offre un raccourci si vous savez que votre requête retournera seulement un seul objet."
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr "Itération de résultats"
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr "Occasionnellement, vous pourriez être capable d'obtenir de meilleures performances en exécutant la requête avec la méthode <literal>iterate()</literal>. Ce sera généralement seulement le cas si vous espérez que les intances réelles d'entité retournées par la requête soient déjà chargées dans la session ou le cache de second niveau. Si elles ne sont pas cachées, <literal>iterate()</literal> sera plus lent que <literal>list()</literal> et pourrait nécessiter plusieurs accès à la base de données pour une simple requête, généralement <emphasis>1</emphasis> pour le select initial qui retourne seulement les identifiants, et <emphasis>n</emphasis> selects supplémentaires pour initialiser les instances réelles."
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr "Requêtes qui retournent des tuples"
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr "Les requêtes d'Hibernate retournent parfois des tuples d'objets, auquel cas chaque tuple est retourné comme un tableau :"
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];
+\n"
+ " Cat mother = (Cat) tuple[1];
+\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr "Résultats scalaires"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr "Des requêtes peuvent spécifier une propriété d'une classe dans la clause <literal>select</literal>. Elles peuvent même appeler des fonctions d'aggrégat SQL. Les propriétés ou les aggrégats sont considérés comme des résultats \"scalaires\" (et pas des entités dans un état persistant)."
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr "Lier des paramètres"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr "Des méthodes de <literal>Query</literal> sont fournies pour lier des valeurs à des paramètres nommés ou à des paramètres de style JDBC <literal>?</literal>. <emphasis>Contrairement à JDBC, les numéros des paramètres d'Hibernate commencent à zéro.</emphasis> Les paramètres nommés sont des identifiants de la forme <literal>:nom</literal> dans la chaîne de caractères de la requête. Les avantages des paramètres nommés sont :"
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr "les paramètres nommés sont insensibles à l'ordre de leur place dans la chaîne de la requête"
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr "ils peuvent apparaître plusieurs fois dans la même requête"
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr "ils sont auto-documentés"
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+ "<![CDATA[//paramètre nomme (préféré)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+ "<![CDATA[//paramètre positionnel\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+ "<![CDATA[//liste de paramètres nommés\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr "Pagination"
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr "Si vous avez besoin de spécifier des liens sur votre ensemble de résultats (le nombre maximum de lignes que vous voulez récupérez et/ou la première ligne que vous voulez récupérer) vous devriez utiliser des méthodes de l'interface <literal>Query</literal> :"
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr "Hibernate sait comment traduite cette requête de limite en SQL natif pour votre SGBD."
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr "Itération \"scrollable\""
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr "Si votre connecteur JDBC supporte les <literal>ResultSet</literal>s \"scrollables\", l'interface <literal>Query</literal> peut être utilisée pour obtenir un objet <literal>ScrollableResults</literal>, lequel permet une navigation flexible dans les résultats de la requête."
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // trouve le premier nom sur chaque page d'une liste alphabétique de noms de chats\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Maintenant, obtiens la première page de chats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr "Notez qu'une connexion ouverte (et un curseur) est requise pour cette fonctionnalité, utilisez <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> si vous avez besoin d'une fonctionnalité de pagination hors ligne."
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr "Externaliser des requêtes nommées"
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr "Vous pouvez aussi définir des requêtes nommées dans le document de mapping. (Souvenez-vous d'utiliser une section <literal>CDATA</literal> si votre requête contient des caractères qui pourraient être interprétés comme des éléments XML.)"
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+ "<![CDATA[<query name=\"eg.DomesticCat.by.name.and.minimum.weight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr "La liaison de paramètres et l'exécution sont fait par programmation :"
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"eg.DomesticCat.by.name.and.minimum.weight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr "Notez que le code réel du programme est indépendant du langage de requête qui est utilisé, vous pouvez aussi définir des requêtes SQL nativez dans les méta-données, ou migrer des requêtes existantes vers Hibernate en les plaçant dans les fichiers de mapping."
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr "Filtrer des collections"
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr "Un <emphasis>filtre</emphasis> de collection est un type spécial de requête qui peut être appliqué à une collection persistante ou à un tableau. La chaîne de requête peut se référer à <literal>this</literal>, correspondant à l'élément de la collection courant."
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(),\n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr "La collection retournée est considérée comme un bag, et c'est une copie de la collection donnée. La collection originale n'est pas modifiée (c'est contraire à l'implication du nom \"filtre\"; mais cohérent avec le comportement attendu)."
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr "Observez que les filtres ne nécessitent pas une clause <literal>from</literal> (bien qu'ils puissent en avoir une si besoin est). Les filtres ne sont pas limités à retourner des éléments de la collection eux-mêmes."
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(),\n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr "Même une requête de filtre vide est utile, par exemple pour charger un sous-ensemble d'éléments dans une énorme collection :"
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr "Requêtes Criteria"
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr "HQL est extrêmement puissant mais certains développeurs préfèrent construire des requêtes dynamiquement, en utilisant l'API orientée objet, plutôt que construire des chaînes de requêtes. Hibernate fournit une API intuitive de requête <literal>Criteria</literal> pour ces cas :"
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr "Les APIs <literal>Criteria</literal> et <literal>Example</literal> associé sont traitées plus en détail dans <xref linkend=\"querycriteria\"/>."
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr "Requêtes en SQL natif"
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr "Vous pouvez exprimer une requête en SQL, en utilisant <literal>createSQLQuery()</literal> et laisser Hibernate s'occuper du mapping des résultats vers des objets. Notez que vous pouvez n'importe quand appeler <literal>session.connection()</literal> et utiliser directement la <literal>Connection</literal> JDBC. Si vous choisissez d'utiliser l'API Hibernate, vous devez mettre les alias SQL entre accolades :"
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list();]]>"
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(
+\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +
+\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +
+\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list()]]>"
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr "Les requêtes SQL peuvent contenir des paramètres nommés et positionnels, comme des requêtes Hibernate. Plus d'informations à propos des requêtes SQL natives dans Hibernate peuvent être trouvées dans <xref linkend=\"querysql\"/>."
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr "Modifier des objets persistants"
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr "Les <emphasis>instances persistantes transactionnelles</emphasis> (c'est-à -dire des objets chargés, sauvegardés, créés ou requêtés par la <literal>Session</literal>) peuvent être manipulées par l'application et n'importe quel changement vers l'état persistant sera persisté lorsque la <literal>Session</literal> est <emphasis>\"flushée\"</emphasis> (traité plus tard dans ce chapitre). Il n'y a pas besoin d'appeler une méthode particulière (comme <literal>update()</literal>, qui a un but différent) pour rendre vos modifications persistantes. Donc la manière la plus directe de mettre à jour l'état d'un objet est de le charger avec <literal>load()</literal>, et puis le manipuler directement, tant que la <literal>Session</literal> est ouverte :"
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr "Parfois ce modèle de programmation est inefficace puisqu'il nécessiterait un <literal>SELECT</literal> SQL (pour charger l'objet) et un <literal>UPDATE</literal> SQL (pour persister son état mis à jour) dans la même session. Aussi Hibernate offre une autre approche, en utilisant des instances détachées."
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr "Notez que Hibernate n'offre par sa propre API pour l'exécution directe d'expressions <literal>UPDATE</literal> ou <literal>DELETE</literal>. Hibernate est un service de <emphasis>gestion d'état</emphasis>, vous n'avez pas à penser aux <emphasis>expressions</emphasis> pour l'utiliser. JDBC est une API parfaite pour exécuter des expressions SQL, vous pouvez obtenir une <literal>Connection</literal> JDBC n'importe quand en appelant <literal>session.connection()</literal>. En outre, la notion d'opérations de masse entre en conflit avec le mapping objet/relationnel pour les applications orientées processus de transactions en ligne. Les futures versions d'Hibernate peuvent cependant fournir des fonctions d'opération de masse. Voir <xref linkend=\"batch\"/> pour les astuces possibles d'opérations groupées."
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr "Modifier des objets détachés"
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr "Beaucoup d'applications ont besoin de récupérer un objet dans une transaction, l'envoyer à la couche interfacée avec l'utilisateur pour les manipulations, puis sauvegarder les changements dans une nouvelle transaction. Les applications qui utilisent cette approche dans un environnement à haute concurrence utilisent généralement des données versionnées pour assurer l'isolation pour les \"longues\" unités de travail."
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr "Hibernate supporte ce modèle en permettant pour le réattachement d'instances détachées l'utilisation des méthodes <literal>Session.update()</literal> ou <literal>Session.merge()</literal> :"
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr ""
+ "<![CDATA[// dans la première session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// dans une couche plus haute de l'application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// plus tard, dans une nouvelle session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr "Si le <literal>Cat</literal> avec l'identifiant <literal>catId</literal> avait déjà été chargé par <literal>secondSession</literal> lorsque l'application a essayé de le réattacher, une exception aurait été levée."
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr "Utilisez <literal>update()</literal> si vous êtes sure que la session ne contient pas déjà une instance persistante avec le même identifiant, et <literal>merge()</literal> si vous voulez fusionner vos modifications n'importe quand sans considérer l'état de la session. En d'autres mots, <literal>update()</literal> est généralement la première méthode que vous devriez appeler dans une session fraîche, pour s'assurer que le réattachement de vos instances détachées est la première opération qui est exécutée."
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr "L'application devrait individuellement <literal>update()</literal> (NdT : mettre à jour) les instances détachées accessibles depuis l'instance détachée donnée si et <emphasis>seulement</emphasis> si elle veut que leur état soit aussi mis à jour. Ceci peut être automatisé bien sûr, en utilisant la <emphasis>persistance transitive</emphasis>, voir <xref linkend=\"objectstate-transitive\"/>."
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr "La méthode <literal>lock()</literal> permet aussi à une application de réassocier un objet avec une nouvelle session. Pourtant, l'instance détachée doit être non modifiée !"
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr ""
+ "<![CDATA[//réassocie :\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//fait une vérification de version, puis réassocie :\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//fait une vérification de version, en utilisant SELECT ... FOR UPDATE, puis réassocie :\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr "Notez que <literal>lock()</literal> peut être utilisé avec différents <literal>LockMode</literal>s, voir la documentation de l'API documentation et le chapitre sur la gestion des transactions pour plus d'informations. Le réattachement n'est pas le seul cas d'utilisation pour <literal>lock()</literal>."
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr "D'autres modèles pour de longues unités de travail sont traités dans <xref linkend=\"transactions-optimistic\"/>."
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr "Détection automatique d'un état"
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr "Les utilisateurs d'Hibernate ont demandé une méthode dont l'intention générale serait soit de sauvegarder une instance éphémère en générant un nouvel identifiant, soit mettre à jour/réattacher les instances détachées associées à l'identifiant courant. La méthode <literal>saveOrUpdate()</literal> implémente cette fonctionnalité."
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr ""
+ "<![CDATA[// dans la première session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// dans une partie plus haute de l'application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// plus tard, dans une nouvelle session\n"
+ "secondSession.saveOrUpdate(cat); // met à jour un état existant (cat a un identifiant non-null)\n"
+ "secondSession.saveOrUpdate(mate); // sauvegarde les nouvelles instances (mate a un identiant null)]]>"
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr "L'usage et la sémantique de <literal>saveOrUpdate()</literal> semble être confuse pour les nouveaux utilisateurs. Premièrement, aussi longtemps que vous n'essayez pas d'utiliser des instances d'une session dans une autre, vous ne devriez pas avoir besoin d'utiliser <literal>update()</literal>, <literal>saveOrUpdate()</literal>, ou <literal>merge()</literal>. Certaines applications n'utiliseront jamais ces méthodes."
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr "Généralement <literal>update()</literal> ou <literal>saveOrUpdate()</literal> sont utilisées dans le scénario suivant :"
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr "l'application charge un objet dans la première session"
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr "l'objet est passé à la couche utilisateur"
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr "certaines modifications sont effectuées sur l'objet"
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr "l'objet est retourné à la couche logique métier"
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr "l'application persiste ces modifications en appelant <literal>update()</literal> dans une seconde sessin"
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr "<literal>saveOrUpdate()</literal> s'utilise dans le cas suivant :"
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr "si l'objet est déjà persistant dans cette session, ne rien faire"
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr "si un autre objet associé à la session a le même identifiant, lever une exception"
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr "si l'objet n'a pas de propriété d'identifiant, appeler <literal>save()</literal>"
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr "si l'identifiant de l'objet a une valeur assignée à un objet nouvellement instancié, appeler <literal>save()</literal>"
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr "si l'objet est versionné (par <literal><version></literal> ou <literal><timestamp></literal>), et la valeur de la propriété de version est la même valeur que celle assignée à un objet nouvellement instancié, appeler <literal>save()</literal>"
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr "sinon mettre à jour l'objet avec <literal>update()</literal>"
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "et <literal>merge()</literal> est très différent :"
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "s'il y a une instance persistante avec le même identifiant couramment associée à la session, copier l'état de l'objet donné dans l'instance persistante"
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr "s'il n'y a pas d'instance persistante associée à cette session, essayer de le charger à partir de la base de données, ou créer une nouvelle instance persistante"
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr "l'instance persistante est retournée"
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr "l'instance donnée ne devient pas associée à la session, elle reste détachée"
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr "Suppression d'objets persistants"
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr "<literal>Session.delete()</literal> supprimera l'état d'un objet de la base de données. Bien sûr, votre application pourrait encore conserver une référence vers un objet effacé. Il est mieux de penser à <literal>delete()</literal> comme rendant une instance persistante éphémère."
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr "<![CDATA[sess.delete(cat);]]>"
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr "Vous pouvez effacer des objets dans l'ordre que vous voulez, sans risque de violations de contrainte de clef étrangère. Il est encore possible de violer une contrainte <literal>NOT NULL</literal> sur une colonne de clef étrangère en effaçant des objets dans le mauvais ordre, par exemple si vous effacer le parent, mais oubliez d'effacer les enfants."
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr "Réplication d'objets entre deux entrepôts de données"
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr "Il est occasionnellement utile de pouvoir prendre un graphe d'instances persistantes et de les rendre persistantes dans un entrepôt différent, sans regénérer les valeurs des identifiants."
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr ""
+ "<![CDATA[//récupère un cat de la base de données\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "// réconcilie la seconde base de données\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr "Le <literal>ReplicationMode</literal> détermine comment <literal>replicate()</literal> traitera les conflits avec les lignes existantes dans la base de données."
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr "<literal>ReplicationMode.IGNORE</literal> - ignore l'objet s'il y a une ligne existante dans la base de données avec le même identifiant"
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr "<literal>ReplicationMode.OVERWRITE</literal> - écrase n'importe quelle ligne existante dans la base de données avec le même identifiant"
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr "<literal>ReplicationMode.EXCEPTION</literal> - lève une exception s'il y une ligne dans la base de données avec le même identifiant"
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.LATEST_VERSION</literal> - écrase la ligne si son numéro de version est plus petit que le numéro de version de l'objet, ou ignore l'objet sinon"
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr "Les cas d'utilisation de cette fonctionnalité incluent la réconciliation de données entrées dans différentes base de données, l'extension des informations de configuration du système durant une mise à jour du produit, retour en arrière sur les changements effectués durant des transactions non-ACID, et plus."
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr "Flush de la session"
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr "De temps en temps la <literal>Session</literal> exécutera les expressions SQL requises pour syncrhoniser l'état de la connexion JDBC avec l'état des objets retenus en mémoire. Ce processus, <emphasis>flush</emphasis>, arrive par défaut aux points suivants :"
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr "lors de certaines exécutions de requête"
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr "lors d'un appel à <literal>org.hibernate.Transaction.commit()</literal>"
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr "lors d'un appel à <literal>Session.flush()</literal>"
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr "Les expressions SQL sont effectuées dans l'ordre suivant :"
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr "insertion des entités, dans le même ordre que celui des objets correspondants sauvegardés par l'appel à <literal>Session.save()</literal>"
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr "mise à jours des entités"
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr "suppression des collections"
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr "suppression, mise à jour et insertion des éléments des collections"
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr "insertion des collections"
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr "suppression des entités, dans le même ordre que celui des objets correspondants qui ont été supprimés par l'appel à <literal>Session.delete()</literal>"
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr "(Une exception est que des objets utilisant la génération <literal>native</literal> d'identifiants sont insérés lorsqu'ils sont sauvegardés.)"
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr "Excepté lorsque vous appelez <literal>flush()</literal> explicitement, il n'y absolument aucune garantie à propos de <emphasis>quand</emphasis> la <literal>Session</literal> exécute les appels JDBC, seulement sur l'<emphasis>ordre</emphasis> dans lequel ils sont exécutés. Cependant, Hibernate garantit que <literal>Query.list(..)</literal> ne retournera jamais de données périmées, ni des données fausses."
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr "Il est possible de changer le comportement par défaut, donc que le flush se produise moins fréquemment. La classe <literal>FlushMode</literal> définit trois modes différents : flush seulement lors du commit (et seulement quand l'API <literal>Transaction</literal> d'Hibernate est utilisée), flush automatiquement en utilisant la procédure expliquée, ou jamais de flush à moins que <literal>flush()</literal> soit appelée explicitement. Le dernier mode est utile pour l'exécution de longues unités de travail, où une <literal>Session</literal> est gardée ouverte et déconnectée pour un long moment (voir <xref linkend=\"transactions-optimistic-longsession\"/>)."
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // permet aux requêtes de retourner un état périmé\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// pourrait retourner des données périmées\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// le changement pour izi n'est pas flushé !\n"
+ "...\n"
+ "tx.commit(); // le flush se produit]]>"
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr "Durant le flush, une exception peut se produire (par exemple, si une opération de la DML viole une contrainte). Puisque les exceptions de gestion impliquent une certaine compréhension du comportement transactionnel d'Hibernate, nous le traitons dans <xref linkend=\"transactions\"/>."
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr "Persistance transitive"
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr "Il est assez pénible de sauvegarder, supprimer, ou réattacher des objets un par un, surtout si vous traitez un graphe d'objets associés. Un cas habituel est une relation parent/enfant. Considérez l'exemple suivant :"
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr "Si les enfants de la relation parent/enfant étaient des types de valeur (par exemple, une collection d'adresses ou de chaînes de caractères), leur cycle de vie dépendraient du parent et aucune action ne serait requise pour \"cascader\" facilement les changements d'état. Si le parent est sauvegardé, les objets enfants de type de valeur sont sauvegardés également, si le parent est supprimé, les enfants sont supprimés, etc. Ceci fonctionne même pour des opérations telles que la suppression d'un enfant de la collection ; Hibernate détectera cela et, puisque les objets de type de valeur ne peuvent pas avoir des références partagées, supprimera l'enfant de la base de données."
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr "Maintenant considérez le même scénario avec un parent et dont les objets enfants sont des entités, et non des types de valeur (par exemple, des catégories et des objets, ou un parent et des chatons). Les entités ont leur propre cycle de vie, supportent les références partagées (donc supprimer une entité de la collection ne signifie pas qu'elle peut être supprimée), et il n'y a par défaut pas de cascade d'état d'une entité vers n'importe quelle entité associée. Hibernate n'implémente pas la <emphasis>persistance par accessibilité</emphasis> par défaut."
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr "Pour chaque opération basique de la session d'Hibernate - incluant <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - il y a un style de cascade correspondant. Respectivement, les styles de cascade s'appellent <literal>persist, merge, save-update, delete, lock, refresh, evict, replicate</literal>. Si vous voulez qu'une opération soit cascadée le long d'une association, vous devez l'indiquer dans le document de mapping. Par exemple :"
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr "Les styles de cascade peuvent être combinés :"
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr "Vous pouvez même utiliser <literal>cascade=\"all\"</literal> pour spécifier que <emphasis>toutes</emphasis> les opérations devraient être cascadées le long de l'association. La valeur par défaut <literal>cascade=\"none\"</literal> spécifie qu'aucune opération ne sera cascadée."
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr "Une style de cascade spécial, <literal>delete-orphan</literal>, s'applique seulement aux associations un-vers-plusieurs, et indique que l'opération <literal>delete()</literal> devrait être appliquée à n'importe quel enfant qui est supprimé de l'association."
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr "Recommandations :"
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr "Cela n'a généralement aucun sens d'activer la cascade sur une association <literal><many-to-one></literal> ou <literal><many-to-many></literal>. Les cascades sont souvent utiles pour des associations <literal><one-to-one></literal> et <literal><one-to-many></literal>."
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr "Si la durée de vie de l'objet enfant est liée à la durée de vie de l'objet parent, faites en un <emphasis>objet du cycle de vie</emphasis> en spécifiant <literal>cascade=\"all,delete-orphan\"</literal>."
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr "Sinon, vous pourriez ne pas avoir besoin de cascade du tout. Mais si vous pensez que vous travaillerez souvent avec le parent et les enfants ensemble dans la même transaction, et que vous voulez vous éviter quelques frappes, considérez l'utilisation de <literal>cascade=\"persist,merge,save-update\"</literal>."
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr "Mapper une association (soit une simple association valuée, soit une collection) avec <literal>cascade=\"all\"</literal> marque l'association comme une relation de style <emphasis>parent/enfant</emphasis> où la sauvegarde/mise à jour/suppression du parent entraîne la sauvegarde/mise à jour/suppression de l'enfant ou des enfants."
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr "En outre, une simple référence à un enfant d'un parent persistant aura pour conséquence la sauvegarde/mise à jour de l'enfant. Cette métaphore est cependant incomplète. Un enfant qui devient non référencé par son parent <emphasis>n'est pas</emphasis> automatiquement supprimée, excepté dans le cas d'une association <literal><one-to-many></literal> mappée avec <literal>cascade=\"delete-orphan\"</literal>. La sémantique précise des opérations de cascade pour une relation parent/enfant est la suivante :"
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr "Si un parent est passé à <literal>persist()</literal>, tous les enfant sont passés à <literal>persist()</literal>"
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr "Si un parent est passé à <literal>merge()</literal>, tous les enfants sont passés à <literal>merge()</literal>"
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr "Si un parent est passé à <literal>save()</literal>, <literal>update()</literal> ou <literal>saveOrUpdate()</literal>, tous les enfants sont passés à <literal>saveOrUpdate()</literal>"
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr "Si un enfant détaché ou éphémère devient référencé par un parent persistant, il est passé à <literal>saveOrUpdate()</literal>"
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr "Si un parent est supprimé, tous les enfants sont passés à <literal>delete()</literal>"
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr "Si un enfant est déréférencé par un parent persistant, <emphasis>rien de spécial n'arrive</emphasis> - l'application devrait explicitement supprimer l'enfant si nécessaire - à moins que <literal>cascade=\"delete-orphan\"</literal> soit paramétré, au quel cas l'enfant \"orphelin\" est supprimé."
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr "Enfin, la cascade des opérations peut être effectuée sur un graphe donné lors de l'<emphasis>appel de l'opération</emphasis> or lors du <emphasis>flush</emphasis> suivant. Toutes les opérations, lorsque cascadées, le sont sur toutes les entités associées atteignables lorsque l'opétation est exécutée. Cependant <literal>save-upate</literal> et <literal>delete-orphan</literal> sont cascadées à toutes les entités associées atteignables lors du flush de la <literal>Session</literal>."
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr "Utilisation des méta-données"
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr "Hibernate requiert un modèle de méta-niveau très riche de toutes les entités et types valués. De temps en temps, ce modèle est très utile à l'application elle même. Par exemple, l'application pourrait utiliser les méta-données d'Hibernate pour implémenter un algorithme de copie en profondeur \"intelligent\" qui comprendrait quels objets devraient copiés (par exemple les types de valeur mutables) et lesquels ne devraient pas l'être (par exemple les types de valeurs immutables et, possiblement, les entités associées)."
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr "Hibernate expose les méta-données via les interfaces <literal>ClassMetadata</literal> et <literal>CollectionMetadata</literal> et la hiérarchie <literal>Type</literal>. Les instances des interfaces de méta-données peuvent être obtenues à partir de la <literal>SessionFactory</literal>."
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// récupère une Map de toutes les propriétés qui ne sont pas des collections ou des associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,742 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr "Guide des outils"
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr "Des outils en ligne de commande, des plugins Eclipse ainsu que des tâches Ant permettent de gérer de cycles de développement complet de projets utilisant Hibernate."
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "Les <emphasis>outils Hibernate</emphasis> actuels incluent des plugins pour l'IDE Eclipse ainsi que des tâches Ant pour l'ingénierie inverse de bases de données existantes :"
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr "<emphasis>Mapping Editor :</emphasis> un éditeur pour les fichiers de mapping XML Hibernate, supportant l'auto-complétion et la mise en valeur de la syntaxe. Il supporte aussi l'auto-complétion automatique pour les noms de classes et les noms de propriété/champ, le rendant beaucoup plus polyvalent qu'un éditeurXML normal."
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>Console :</emphasis> la console est une nouvelle vue d'Eclipse. En plus de la vue d'ensemble arborescente de vos configurations de console, vous obtenez aussi une vue interactive de vos classes persistantes et de leurs relations. La console vous permet d'exécuter des requête HQL dans votre base de données et de parcourir les résultats directement dans Eclipse."
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>Development Wizards :</emphasis> plusieurs assistants sont fournis avec les outils d'Hibernate pour Eclipse ; vous pouvez utiliser un assistant pour générer rapidement les fichiers de configuration d'Hibernate (cfg.xml), ou vous pouvez même complètement générer les fichiers de mapping Hibernate et les sources des POJOs à partir d'un schéma de base de données existant. L'assistant d'ingénierie inverse supporte les modèles utilisateur."
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr "Tâches Ant :"
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr "Veuillez-vous référer au paquet <emphasis>outils Hibernate</emphasis> et sa documentation pour plus d'informations."
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr "Pourtant, le paquet principal d'Hibernate arrive avec un lot d'outils intégrés (il peut même être utilisé de \"l'intérieur\" d'Hibernate à la volée) : <emphasis>SchemaExport</emphasis> aussi connu comme <literal>hbm2ddl</literal>."
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr "Génération automatique du schéma"
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "La DDL peut être générée à partir de vos fichiers de mapping par un utilitaire d'Hibernate. Le schéma généré inclut les contraintes d'intégrité référentielle (clefs primaires et étrangères) pour les tables d'entités et de collections. Les tables et les séquences sont aussi créées pour les générateurs d'identifiant mappés."
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr "Vous <emphasis>devez</emphasis> spécifier un <literal>Dialect</literal> SQL via la propriété <literal>hibernate.dialect</literal> lors de l'utilisation de cet outils, puisque la DDL est fortement dépendante de la base de données."
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr "D'abord, personnalisez vos fichiers de mapping pour améliorer le schéma généré."
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr "Personnaliser le schéma"
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr "Plusieurs éléments du mapping hibernate définissent des attributs optionnels nommés <literal>length</literal>, <literal>precision</literal> et <literal>scale</literal>. Vous pouvez paramétrer la longueur, la précision,... d'une colonne avec ces attributs."
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr "Certains éléments acceptent aussi un attribut <literal>not-null</literal> (utilisé pour générer les contraintes de colonnes <literal>NOT NULL</literal>) et un attribut <literal>unique</literal> (pour générer une contrainte de colonne <literal>UNIQUE</literal>)."
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr "Un attribut <literal>unique-key</literal> peut être utilisé pour grouper les colonnes en une seule contrainte d'unicité. Actuellement, la valeur spécifiée par l'attribut <literal>unique-key</literal> n'est <emphasis>pas</emphasis> utilisée pour nommer la contrainte dans le DDL généré, elle sert juste à grouper les colonnes dans le fichier de mapping."
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ " <property name=\"employeeId\" unique-key=\"OrgEmployeeId\"/>]]>"
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr "Un attribut <literal>index</literal> indique le nom d'un index qui sera créé en utilisant la ou les colonnes mappées. Plusieurs colonnes peuvent être groupées dans un même index, en spécifiant le même nom d'index."
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr "Un attribut <literal>foreign-key</literal> peut être utilisé pour surcharger le nom des clés étrangères générées."
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "Plusieurs éléments de mapping acceptent aussi un élément fils <literal><column></literal>. Ceci est utile pour les type multi-colonnes:"
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr "L'attribut <literal>default</literal> vous laisse spécifier une valeur par défaut pour une colonnes (vous devriez assigner la même valeur à la propriété mappée avant de sauvegarder une nouvelle instance de la classe mappée)."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "L'attribut <literal>sql-type</literal> laisse l'utilisateur surcharger le mapping par défaut du type Hibernate vers un type SQL."
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr "L'attribut <literal>check</literal> permet de spécifier une contrainte de vérification."
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Summary"
+msgstr "Summary"
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr "Attribut"
+
+#: index.docbook:164
+msgid "Values"
+msgstr "Valeur"
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr "Interprétation"
+
+#: index.docbook:170
+msgid "length"
+msgstr "length"
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr "numérique"
+
+#: index.docbook:172
+msgid "column length"
+msgstr "taille d'une colonne"
+
+#: index.docbook:175
+msgid "precision"
+msgstr "precision"
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr "précision décimale de la colonne"
+
+#: index.docbook:180
+msgid "scale"
+msgstr "scale"
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr "scale décimale de la colonne"
+
+#: index.docbook:185
+msgid "not-null"
+msgstr "not-null"
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr "true|false"
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr "spécifie que la colonne doit être non-nulle"
+
+#: index.docbook:190
+msgid "unique"
+msgstr "unique"
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr "spécifie que la colonne doit avoir une contrainte d'unicité"
+
+#: index.docbook:195
+msgid "index"
+msgstr "index"
+
+#: index.docbook:196
+msgid "index_name"
+msgstr "index_name"
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr "spécifie le nom d'un index (multi-colonnes)"
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr "unique-key"
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr "unique_key_name"
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr "spécifie le nom d'une contrainte d'unicité multi-colonnes"
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr "foreign-key"
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr "foreign_key_name"
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "spécifie le nom d'une contrainte de clé étrangère générée pour une association, utilisez-la avec les éléments de mapping <one-to-one>, <many-to-one>, <key>, et <many-to-many> Notez que les extrêmités <literal>inverse=\"true\"</literal> se seront pas prises en compte par <literal>SchemaExport</literal>."
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr "sql-type"
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr "SQL column_type"
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr "surcharge le type par défaut (attribut de l'élément <literal><column></literal> uniquement)"
+
+#: index.docbook:225
+msgid "default"
+msgstr "default"
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr "expression SQL"
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr "spécifie une valeur par défaut pour la colonne"
+
+#: index.docbook:232
+msgid "check"
+msgstr "check"
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr "crée une contrainte de vérification sur la table ou la colonne"
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr "L'élément <literal><comment></literal> vous permet de spécifier un commentaire pour le schéma généré."
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr "Ceci a pour résultat une expression <literal>comment on table</literal> ou <literal>comment on column</literal> dans la DDL générée (où supportée)."
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr "Exécuter l'outil"
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "L'outil <literal>SchemaExport</literal> génère un script DDL vers la sortie standard et/ou exécute les ordres DDL."
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>classpath_hibernate</emphasis> <literal>net.sf.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options fichiers_de_mapping</emphasis>"
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr "<literal>SchemaExport</literal> Options de la ligne de commande"
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr "Option"
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr "Description"
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr "--quiet"
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr "ne pas écrire le script vers la sortie standard"
+
+#: index.docbook:289
+msgid "--drop"
+msgstr "--drop"
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr "supprime seuleument les tables"
+
+#: index.docbook:293
+msgid "--create"
+msgstr "--create"
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr "ne créé que les tables"
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr "--text"
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr "ne pas exécuter sur la base de données"
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr "--output=my_schema.ddl"
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr "écrit le script ddl vers un fichier"
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr "--naming=eg.MyNamingStrategy"
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr "sélectionne une <literal>NamingStrategy</literal>"
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr "--config=hibernate.cfg.xml"
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr "lit la configuration Hibernate à partir d'un fichier XML"
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr "lit les propriétés de la base de données à partir d'un fichier"
+
+#: index.docbook:317
+msgid "--format"
+msgstr "--format"
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr "formatte proprement le SQL généré dans le script"
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr "--delimiter=x"
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr "paramètre un délimiteur de fin de ligne pour le script"
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr "Vous pouvez même intégrer <literal>SchemaExport</literal> dans votre application :"
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+
+#: index.docbook:337
+msgid "Properties"
+msgstr "Propriétés"
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr "Les propriétés de la base de données peuvent être spécifiées"
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "comme propriétés système avec <literal>-D</literal><emphasis><property></emphasis>"
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr "dans <literal>hibernate.properties</literal>"
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr "dans un fichier de propriétés déclaré avec <literal>--properties</literal>"
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr "Les propriétés nécessaires sont :"
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr "SchemaExport Connection Properties"
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr "Nom de la propriété"
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr "classe du driver JDBC"
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr "URL JDBC"
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:381
+msgid "database user"
+msgstr "utilisateur de la base de données"
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:385
+msgid "user password"
+msgstr "mot de passe de l'utilisateur"
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:389
+msgid "dialect"
+msgstr "dialecte"
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr "Utiliser Ant"
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr "Vous pouvez appeler <literal>SchemaExport</literal> depuis votre script de construction Ant :"
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ "\n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr "Mises à jour incrémentales du schéma"
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr "L'outil <literal>SchemaUpdate</literal> mettra à jour un schéma existant en effectuant les changement par \"incrément\". Notez que <literal>SchemaUpdate</literal> dépends beaucoup de l'API JDBC metadata, il ne fonctionnera donc pas avec tous les drivers JDBC."
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>classpath_hibernate</emphasis> <literal>net.sf.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options fichiers_de_mapping</emphasis>"
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr "<literal>SchemaUpdate</literal> Options de ligne de commande"
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr "ne pas exporter vers la base de données"
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr "Utiliser Ant pour des mises à jour de schéma par incrément"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr "Vous pouvez appeler <literal>SchemaUpdate</literal> depuis le script Ant :"
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ "\n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr "Validation du schéma"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr "L'outil <literal>SchemaValidator</literal> validera que le schéma existant correspond à vos documents de mapping. Notez que le <literal>SchemaValidator</literal> dépends de l'API metadata de JDBC, il ne fonctionnera donc pas avec tous les drivers JDBC. Cet outil est extrêmement utile pour tester."
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr "<literal>SchemaValidator</literal> Options de ligne de commande"
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "Option"
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr "Description"
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr "Utiliser Ant pour la validation du Schéma"
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr "Vous pouvez appeler <literal>SchemaValidator</literal> depuis le script Ant:"
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,791 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr "Transactions et accès concurrents"
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "L'un des principaux avantages du mécanisme de contrôle des accès concurrents d'Hibernate est qu'il est très facile à comprendre. Hibernate utilise directement les connexions JDBC ainsi que les ressources JTA sans y ajouter davantage de mécanisme de blocage. Nous vous recommandons de vous familiariser avec les spécifications JDBC, ANSI et d'isolement de transaction de la base de données que vous utilisez."
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr "Hibernate ne vérouille pas vos objets en mémoire. Votre application peut suivre le comportement défini par le niveau d'isolation de vos transactions de base de données. Notez que grâce à la <literal>Session</literal>, qui est aussi un cache de scope transaction, Hibernate fournit des lectures répétées pour les récupération par identifiants et les requêtes d'entités (pas celle de valeurs scalaires)."
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "En addition au versionning pour le controle automatique de concurrence, Hibernate fournit une API (mineure) pour le verrouillage perssimiste des enregistrements, en générant une syntaxe <literal>SELECT FOR UPDATE</literal>. Le controle de concurrence optimiste et cette API seront détaillés plus tard dans ce chapitre."
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "Nous aborderons la gestion des accès concurrents en discutant de la granularité des objets <literal>Configuration</literal>, <literal>SessionFactory</literal>, et <literal>Session</literal>, ainsi que de certains concepts relatifs à la base de données et aux longues transactions applicatives."
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr "Gestion de session et délimitation de transactions"
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "Il est important de savoir qu'un objet <literal>SessionFactory</literal> est un objet complexe et optimisé pour fonctionner avec les threads(thread- safe). Il est coûteux à créer et est ainsi prévu pour n'être instancié qu?une seule fois via un objet <literal>Configuration</literal> au démarrage de l'application, et être partagé par tous les threads d'une application."
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr "Un objet <literal>Session</literal> est relativement simple et n'est threadsafe. Il est également peu coûteux à créer. Il devrait n'être utilisé qu'une seule fois, pour un processus d'affaire ou une unité de travail ou une conversation et ensuite être relâché. Un objet <literal>Session</literal> ne tentera pas d'obtenir de connexion ( <literal>Connection</literal> ) JDBC (ou de <literal>Datasource</literal> ) si ce n'est pas nécessaire."
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr "Afin de compléter ce tableau, vous devez également penser aux transactions de base de données. Une transaction de base de données se doit d'être la plus courte possible afin de réduire les risques de collision sur des enregistrements verrouillés. De longues transactions à la base de données nuiront à l'extensibilité de vos applications lorsque confrontées à de hauts niveaux de charge. Par conséquent, il n'est jamais bon de maintenir une transaction ouverte pendant la durée de reflexion de l'utilisateur, jusqu'a ce que l'unité de travail soit achevée."
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr "Maintenant, comment délimiter une unité de travail? Est-ce qu'une instance de <literal>Session</literal> peut avoir une durée de vie dépassant plusieurs transactions à la base de données, ou bien est-ce que celles-ci doivent être liées une à une? Quand faut-il ouvrir et fermer une <literal>Session</literal> ? Comment définir la démarcation de vos transactions à la base de données?"
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr "Unité de travail"
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr "Il est important de mentionner que d'utiliser un paradigme <emphasis>session-par-operation</emphasis> est un anti-pattern. Autrement dit: n'ouvrez et ne fermez pas la <literal>Session</literal> à chacun de vos accès simples à la base de données dans un même thread! Bien sûr, le même raisonnement s'applique sur la gestion des transactions à la base de données. Les appels à la base de données devraient être faits en ordre et selon une séquence définie. Ils devraient également être regroupés en des unités de travail atomiques. (Notez que l?utilisation d?une connexion auto-commit constitue le même anti-pattern. Ce mode de fonctionnement existe pour les applications émettant des commandes SQL à partir d?une console. Hibernate désengage le mode auto-commit et s'attend à ce qu'un serveur d'applications le fasse également.) Les transactions avec la base de données ne sont jamais optionnelles, toute communication avec une base de données doit se dé!
rouler dans une transaction, peu importe si vous lisez ou écrivez des données. Comme évoqué, le comportement auto-commit pour lire les données devrait être évité, puisque plusieurs petites transactions ne seront jamais aussi efficaces qu'une seule plus grosse clairement définie comme unité de travail. Ce dernier choix et en plus beaucoup plus facile a maintenir et à faire évoluer."
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "Le pattern d'utilisation le plus fréquemment rencontré dans des applications clients serveur multi-usagers est le <emphasis>session-per-request</emphasis> (littéralement : Session par requête). Dans ce modèle, la requête d'un client est envoyée à un serveur (Où la couche de persistance est implémentée via Hibernate), une nouvelle <literal>Session</literal> est ouverte et toutes les opérations d'accès à la base de données sont exécutées à l'intérieur de celle-ci. Lorsque le travail est terminé (et que les réponses à envoyer au client ont été préparées), la session est flushée et fermée. Une seule transaction à la base de données peut être utilisée pour répondre à la requête du client. La transaction est démarrée et validée au même moment où la Session est ouverte et fermée. La relation entre la <literal>Session</literal> et la <literal>Transaction</literal> est donc one-to-one. Ce modèle permet de répondre parfaitement aux a!
ttentes de la grande majorité des applications."
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr "Le défi réside dans l'implémentation. Hibernate fournit une fonction de gestion de la \"session courante\" pour simplifier ce pattern. Tout ce que vous devez faire est démarrer une transaction lorsqu'une requête est traitée par le serveur, et la terminer avant que la réponse ne soit envoyée au client. Vous pouvez le faire de la manière que vous voulez, les solutions communes sont un <literal>ServletFilter</literal>, l'interception via AOP avec une pointcut sur les méthodes de type \"service\", ou un conteneur avec interception/proxy. Un conteneur EJB est un moyen standard d'implémenter ce genre d'acpect tranverse comme la démarcation des transactions sur les EJBs session, de manière déclarative avec CMT. Si vous décidez d'utiliser la démarcation programmatique des transactions, préferrez l'API Hibernate <literal>Transaction</literal> détaillée plus tard dans ce chapitre, afin de facilité l'utilisation et la portabilité du code."
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "Votre application peut accéder la \"session courante\" pour exécuter une requête en invoquant simplement <literal>sessionFactory.getCurrentSession()</literal> n'importe où et autant de fois que souhaité. Vous obtiendrez toujours une <literal>Session</literal> dont le scope est la transaction courante avec la base de données. Ceci doit être configuré soit dans les ressources local ou dans l'environnement JTA, voir <xref linkend=\"architecture-current-session\"/>."
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "Il est parfois utile d'étendre le scope d'une <literal>Session</literal> et d'une transaction à la base de données jusqu'à ce que \"la vue soit rendue\". Ceci est particulièrement utile dans des applications à base de servlet qui utilisent une phase de rendue séparée une fois que la réponse a été préparée. Etendre la transaction avec la base de données jusqu'à la fin du rendering de la vue est aisé si vous implémentez votre propre intercepteur. Cependant, ce n'est pas facile si vous vous appuyez sur les EJBs avec CMT, puisqu'une transaction sera achevée au retour de la méthode EJB, avant le rendu de la vue. Rendez vous sur le site Hibernate et sur le forum pour des astuces et des exemples sur le pattern <emphasis>Open Session in View</emphasis> pattern.."
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr "Longue conversation"
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "Le paradigme <emphasis>session-per-request</emphasis> n'est pas le seul élément à utiliser dans le design de vos unités de travail. Plusieurs processus d'affaire requièrent toute une série d'interactions avec l'utilisateur, entrelacées d'accès à la base de donnée. Dans une application Web ou une application d'entreprise, il serait inacceptable que la durée de vie d'une transaction s'étale sur plusieurs interactions avec l'usager. Considérez l'exemple suivant:"
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "Un écran s'affiche. Les données vues par l'usager ont été chargées dans l'instance d'un objet <literal>Session</literal> , dans le cadre d'une transaction de base de données. L'usager est libre de modifier ces objets."
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr "L'usager clique \"Sauvegarder\" après 5 minutes et souhaite persister les modifications qu'il a apportées. Il s'attend à être la seule personne a avoir modifié ces données et qu'aucune modification conflictuelle ne se soit produite durant ce laps de temps."
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr "Ceci s'appelle une unité de travail. Du point de vue de l'utilisateur: une <emphasis>conversation</emphasis> (ou <emphasis>transaction d'application</emphasis>). Il y a plusieurs façon de mettre ceci en place dans votre application."
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "Une première implémentation naïve pourrait consister à garder la <literal>Session</literal> et la transaction à la base de données ouvertes durant le temps de travail de l'usager, à maintenir les enregistrements verrouillés dans la base de données afin d'éviter des modifications concurrentes et de maintenir l'isolation et l'atomicité de la transaction de l'usager. Ceci est un anti-pattern à éviter, puisque le verrouillage des enregistrements dans la base de données ne permettrait pas à l'application de gérer un grand nombre d'usagers concurrents."
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr "Il apparaît donc évident qu'il faille utiliser plusieurs transactions BDD afin d'implémenter la conversation. Dans ce cas, maintenir l'isolation des processus d'affaire devient partiellement la responsabilité de la couche applicative. Ainsi, la durée de vie d'une conversation devrait englober celle d'une ou de plusieurs transactions de base de données. Celle-ci sera atomique seulement si l'écriture des données mises à jour est faite exclusivement par la dernière transaction BDD la composant. Toutes les autres sous transactions BD ne doivent faire que la lecture de données. Ceci est relativement facile à mettre en place, surtout avec l'utilisation de certaines fonctionnalités d'Hibernate:"
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr "<emphasis>Versionnage Automatique</emphasis> - Hibernate peut gérer automatiquement les accès concurrents de manière optimiste et détecter si une modification concurrente s'est produite durant le temps de réflexion d'un usager."
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "<emphasis>Objets Détachés</emphasis> - Si vous décidez d'utiliser le paradigme <emphasis>session-par-requête</emphasis> discuté plus haut, toutes les entités chargées en mémoire deviendront des objets détachés durant le temps de réflexion de l'usager. Hibernate vous permet de rattacher ces objets et de persister les modifications y ayant été apportées. Ce pattern est appelé: <emphasis>session-per- request-with-detached-objects</emphasis> (littéralement: session- par-requête-avec-objets-détachés). Le versionnage automatique est utilisé afin d'isoler les modifications concurrentes."
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr "<emphasis>Session Longues (conversation)</emphasis> - Une <literal>Session</literal> Hibernate peut être déconnectée de la couche JDBC sous-jacente après que commit() ait été appelé sur une transaction à la base de données et reconnectée lors d'une nouvelle requête-client. Ce pattern s'appelle: <emphasis>session-per-conversation</emphasis> (Littéralement: session-par- conversation) et rend superflu le rattachement des objets. Le versionnage automatique est utilisé afin d'isoler les modifications concurrentes."
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr "Les deux patterns <emphasis>session-per-request-with- detached- objects</emphasis> (session-par-requête-avec-objets- détachés) et <emphasis>session-per-conversation</emphasis> (session-par-conversation) ont chacun leurs avantages et désavantages qui seront exposés dans ce même chapitre, dans la section au sujet du contrôle optimiste de concurrence."
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr "L'identité des objets"
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr "Une application peut accéder à la même entité persistante de manière concurrente dans deux <literal>Session</literal> s différentes. Toutefois, une instance d'une classe persistante n'est jamais partagée par deux instances distinctes de la classe <literal>Session</literal> . Il existe donc deux notions de l'identité d'un objet:"
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr "Identité BD"
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr "foo.getId().equals( bar.getId() )"
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr "Identité JVM"
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr "foo==bar"
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr "Ainsi, pour des objets attachés à une <literal>Session</literal> <emphasis>précise</emphasis> (dans la cadre d'exécution (scope) d'une instance de <literal>Session</literal> ), ces deux notions d'identité sont équivalentes et garanties par Hibernate. Par contre, si une application peut accéder de manière concurrente à la même entité persistante dans deux sessions différentes, les deux instances seront en fait différentes (en ce qui a trait à l'identité JVM). Les conflits sont résolus automatiquement par approche optimiste grâce au système de versionnage automatique lorsque <literal>Session.flush()</literal> ou <literal>Transaction.commit()</literal> est appelé."
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr "Cette approche permet de reléguer à Hibernate et à la base de données sous-jacente le soin de gérer les problèmes d'accès concurrents. Cette manière de faire assure également une meilleure extensibilité de l'application puisque assurer l'identité JVM dans un thread ne nécessite pas de mécanismes de verrouillage coûteux ou d'autres dispositifs de synchronisation. Une application n'aura jamais le besoin de synchroniser des objets d'affaire tant qu'elle peut garantir qu'un seul thread aura accès à une instance de <literal>Session</literal> . Dans le cadre d'exécution d'un objet <literal>Session</literal> , l'application peut utiliser en toute sécurité <literal>== </literal> pour comparer des objets."
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "Une application qui utiliserait <literal>==</literal> à l'extérieur du cadre d'exécution d'une <literal>Session</literal> pourrait obtenir des résultats inattendus et causer certains effets de bords. Par exemple, si vous mettez 2 objets dans le même <literal>Set</literal> , ceux-ci pourraient avoir la même identité BD (i.e. ils représentent le même enregistrement), mais leur identité JVM pourrait être différente (elle ne peut, par définition, pas être garantie sur deux objets détachés). Le développeur doit donc redéfinir l'implémentation des méthodes <literal>equals()</literal> et <literal>hashcode()</literal> dans les classes persistantes et y adjoindre sa propre notion d'identité. Il existe toutefois une restriction: Il ne faut jamais utiliser uniquement l'identifiant de la base de données dans l'implémentation de l'égalité; Il faut utiliser une clé d'affaire, généralement une combinaison de plusieurs attributs uniques, si possible immu!
ables. Les identifiants de base de données vont changer si un objet transitoire (transient) devient persistant. Si une instance transitoire est contenue dans un <literal>Set</literal> , changer le hashcode brisera le contrat du <literal>Set</literal> . Les attributs pour les clés d'affaire n'ont pas à être aussi stables que des clés primaires de bases de données. Il suffit simplement qu'elles soient stables tant et aussi longtemps que les objets sont dans le même <literal>Set</literal> . Veuillez consulter le site web Hibernate pour des discussions plus pointues à ce sujet. Notez que ce concept n'est pas propre à Hibernate mais bien général à l'implémentation de l'identité et de l'égalité en Java."
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr "Problèmes communs"
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr "Bien qu'il puisse y avoir quelques rares exceptions à cette règle, il est recommandé de ne jamais utiliser les anti-patterns <emphasis>session-per- user-session</emphasis> et <emphasis>session-per-application</emphasis> . Vous trouverez ici- bas quelques problèmes que vous risquez de rencontrer si vous en faite l?utilisation. (Ces problèmes pourraient quand même survenir avec des patterns recommandés) Assurez-vous de bien comprendre les implications de chacun des patterns avant de prendre votre décision."
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "L'objet <literal>Session</literal> n?est pas conçu pour être utilisé par de multiples threads. En conséquence, les objets potentiellement multi-thread comme les requêtes HTTP, les EJB Session et Swing Worker, risquent de provoquer des conditions de course dans la <literal>Session</literal> si celle-ci est partagée. Dans un environnement web classique, il serait préférable de synchroniser les accès à la session http afin d?éviter qu?un usager ne recharge une page assez rapidement pour que deux requêtes s?exécutant dans des threads concurrents n?utilisent la même <literal>Session</literal> ."
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr "Lorsque Hibernate lance une exception, le roll back de la transaction en cours doit être effectué et la <literal>Session</literal> doit être immédiatement fermée. (Ceci sera exploré plus tard dans le chapitre.) Si la <literal>Session</literal> est directement associée à une application, il faut arrêter l?application. Le roll back de la transaction ne remettra pas les objets dans leur état du début de la transaction. Ainsi, ceux-ci pourraient être désynchronisés d?avec les enregistrements. (Généralement, cela ne cause pas de réels problèmes puisque la plupart des exceptions sont non traitables et requièrent la reprise du processus d?affaire ayant échoué.)"
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr "La <literal>Session</literal> met en mémoire cache tous les objets persistants (les objets surveillés et dont l'état est géré par Hibernate.) Si la <literal>Session</literal> est ouverte indéfiniment ou si une trop grande quantité d'objets y est chargée, l?utilisation de la mémoire peut potentiellement croître jusqu?à atteindre le maximum allouable à l?application (java.lang.OutOfMemoryError.) Une solution à ce problème est d?appeler les méthodes <literal>Session.clear()</literal> et <literal>Session.evict()</literal> pour gérer la mémoire cache de la <literal>Session</literal> . Vous pouvez également utiliser des stored procedures si vous devez lancer des traitements sur de grandes quantités d?informations. Certaines solutions sont décrites ici : <xref linkend=\"batch\"/> . Garder une <literal>Session</literal> ouverte pour toute la durée d?une session usager augmente également considérablement le risque de travailler avec de l?information pÃ!
©rimée."
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr "Démarcation des transactions"
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "La démarcation des transactions est importante dans le design d?une application. Aucune communication avec la base de données ne peut être effectuée à l?extérieur du cadre d?une transaction. (Il semble que ce concept soit mal compris par plusieurs développeurs trop habitués à utiliser le mode auto-commit.) Même si certains niveaux d'isolation et certaines possibilités offertes par les bases de données permettent de l?éviter, il n'est jamais désavantageux de toujours explicitement indiquer les bornes de transaction pour les opérations complexes comme pour les opérations simples de lecture."
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr "Une application utilisant Hibernate peut s'exécuter dans un environnement léger n?offrant pas la gestion automatique des transactions (application autonome, application web simple ou applications Swing) ou dans un environnement J2EE offrant des services de gestion automatique des transactions JTA. Dans un environnement simple, Hibernate a généralement la responsabilité de la gestion de son propre pool de connexions à la base de données. Le développeur de l'application doit manuellement délimiter les transactions. En d'autres mots, il appartient au développeur de gérer les appels à <literal>Transaction.begin()</literal> , <literal>Transaction.commit()</literal> et <literal>Transaction.rollback()</literal> . Un environnement transactionnel J2EE (serveur d'application J2EE) doit offrir la gestion des transactions au niveau du container J2EE. Les bornes de transaction peuvent normalement être définies de manière déclarative dans les descripteurs de dépl!
oiement d'EJB Session, par exemple. La gestion programmatique des transactions n'y est donc pas nécessaire. Même les appels à <literal>Session.flush()</literal> sont faits automatiquement."
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "Il peut être requis d'avoir une couche de persistance portable. Hibernate offre donc une API appelée <literal>Transaction</literal> qui sert d'enveloppe pour le système de transaction natif de l'environnement de déploiement. Il n'est pas obligatoire d'utiliser cette API mais il est fortement conseillé de le faire, sauf lors de l'utilisation de CMT Session Bean (EJB avec transactions gérées automatiquement par le container EJB)."
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr "Il existe quatre étapes disctinctes lors de la fermeture d'une <literal>Session</literal>"
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr "flush de la session"
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr "commit de la transaction"
+
+#: index.docbook:395
+msgid "close the session"
+msgstr "Fermeture de la session (Close)"
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr "<para>Gestion des exceptions</para>"
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr "La synchronisation de bdd depuis la session (flush) a déjà été expliqué, nous nous attarderons maintenant à la démarcation des transactions et à la gestion des exceptions dans les environnements légers et les environnements J2EE."
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr "Environnement non managé"
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "Si la couche de persistance Hibernate s'exécute dans un environnement non managé, les connexions à la base de données seront généralement prises en charge par le mécanisme de pool d'Hibernate. La gestion de la session et de la transaction se fera donc de la manière suivante:"
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr "Vous n'avez pas à invoquer <literal>flush()</literal> explicitement sur la <literal>Session</literal> - l'appel de <literal>commit()</literal> déclenchera automatiquement la synchronisation (selon le <xref linkend=\"objectstate-flushing\"/>FlushMode de la session. Un appel à <literal>close()</literal> marque la fin de la session. La conséquence directe est que la connexion à la base de données sera relachée par la session. Ce code est portable est fonctionne dans les environnements non managé ET les environnements JTA."
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr "Une solution plus flexible est la gestion par contexte fourni par Hibernate que nous avons déjà rencontré:"
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr "Vous ne verrez probablement jamais ces exemples de code dans les applications; les exceptions fatales (exceptions du système) ne devraient être traitées que dans la couche la plus \"haute\". En d'autres termes, le code qui exécute les appels à Hibernate (à la couche de persistance) et le code qui gère les <literal>RuntimeException</literal> (qui ne peut généralement effectuer qu'un nettoyage et une sortie) sont dans des couches différentes. La gestion du contexte courant par Hibernate peut simplifier notablement ce design, puisque vous devez accéder à la gestion des exceptions de la <literal>SessionFactory</literal>, ce qui est décrit plus tard dans ce chapitre."
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "Notez que vous devriez sélectionner <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (le défaut), pour le second exemple <literal>\"thread\"</literal> comme <literal>hibernate.current_session_context_class</literal>."
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr "Utilisation de JTA"
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "Si votre couche de persistance s'exécute dans un serveur d'application (par exemple, derrière un EJB Session Bean), toutes les datasource utilisées par Hibernate feront automatiquement partie de transactions JTA globales. Hibernate propose deux stratégies pour réussir cette intégration."
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr "Si vous utilisez des transactions gérées par un EJB (bean managed transactions - BMT), Hibernate informera le serveur d'application du début et de la fin des transactions si vous utilisez l'API <literal>Transaction</literal> . Ainsi, le code de gestion des transactions sera identique dans les deux types d'environnements."
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr "Ou encore, avec la gestion automatique de contexte:"
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr "Avec CMT, la démarcation des transactions est faite dans les descripteurs de déploiement des Beans Sessions et non de manière programmmatique, ceci réduit le code:"
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr "Dans un EJB CMT même le rollback intervient automatiquement, puisqu'une <literal>RuntimeException</literal> non traitée et soulevée par une méthode d'un bean session indique au conteneur d'annuler la transaction globale. <emphasis>Ceci veut donc dire que vous n'avez pas à utiliser l'API <literal>Transaction</literal> d'Hibernate dans CMT.</emphasis>"
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr "Notez que le fichier de configuration Hibernate devrait contenir les valeurs <literal>org.hibernate.transaction.JTATransactionFactory</literal> dans un environnement BMT ou <literal>org.hibernate.transaction.CMTTransactionFactory</literal> dans un environnement CMT là où vous configurez votre transaction factory Hibernate. N'oubliez pas non plus de spécifier le paramètre <literal>org.hibernate.transaction.manager_lookup_class</literal> . De plus, assurez vous de fixez votre <literal>hibernate.current_session_context_class</literal> soit à <literal>\"jta\"</literal> ou de ne pas le configurer (compatibilité avec les versions précédentes)."
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr "La méthode <literal>getCurrentSession()</literal> a un inconvénient dans les environnement JTA. Il y a une astuce qui est d'utiliser un mode de libération de connexion <literal>after_statement</literal> , qui est alors utilisé par défaut. Du à une étrange limitation de la spec JTA, il n'est pas possible pour Hibernate de nettoyer et ferme automatiquement un <literal>ScrollableResults</literal> ouvert ou une instance d'<literal>Iterator</literal> retournés <literal>scroll()</literal> ou <literal>iterate()</literal>. Vous <emphasis>devez</emphasis> libérer le curseur base de données sous jacent ou invoquer <literal>Hibernate.close(Iterator)</literal> explicitement depuis un bloc <literal>finally</literal>. (Bien sur, la plupart des applications peuvent éviter d'uiliser <literal>scroll()</literal> ou <literal>iterate()</literal> dans un code CMT.)"
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr "<title>Gestion des exceptions</title>"
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "Si une <literal>Session</literal> lance une exception (incluant les exceptions du type <literal>SQLException</literal> ou d'un sous-type), vous devez immédiatement faire le rollback de la transaction, appeler <literal>Session.close()</literal> et relâcher les références sur l'objet <literal>Session</literal> . La <literal>Session</literal> contient des méthodes pouvant la mettre dans un état inutilisable. Vous devez considérer qu'<emphasis>aucune</emphasis> exception lancée par Hibernate n'est traitable. Assurez-vous de fermer la session en faisant l'appel à <literal>close()</literal> dans un bloc <literal>finally</literal> ."
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr "L'exception <literal>HibernateException</literal> , qui englobe la plupart des exceptions pouvant survenir dans la couche de persistance Hibernate, est une exception non vérifiée (Ceci n'était pas le cas dans certaines versions antérieures de Hibernate.) Il est de notre avis que nous ne devrions pas forcer un développeur à gérer une exception qu'il ne peut de toute façon pas traiter dans une couche technique. Dans la plupart des applications, les exceptions non vérifiées et les exceptions fatales sont gérées en amont du processus (dans les couches hautes) et un message d'erreur est alors affiché à l'usager (ou un traitement alternatif est invoqué.) Veuillez noter qu'Hibernate peut également lancer des exceptions non vérifiées d'un autre type que <literal>HibernateException</literal> . Celles-ci sont également non traitables et vous devez les traiter comme telles."
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "Hibernate englobe les <literal>SQLException</literal> s lancées lors des interactions directes avec la base de données dans des exceptions de type: <literal>JDBCException</literal> . En fait, Hibernate essaiera de convertir l'exception dans un sous-type plus significatif de <literal>JDBCException</literal> . L'exception <literal>SQLException</literal> sous-jacente est toujours disponible via la méthode <literal>JDBCException.getCause()</literal> . Cette conversion est faite par un objet de type <literal>SQLExceptionConverter</literal> , qui est rattaché à l'objet <literal>SessionFactory</literal> . Par défaut, le <literal>SQLExceptionConverter</literal> est associé au dialecte de BD configuré dans Hibernate. Toutefois, il est possible de fournir sa propre implémentation de l'interface. (Veuillez vous référer à la javadoc sur la classe <literal>SQLExceptionConverterFactory</literal> pour plus de détails. Les sous-types standard de <literal>JDBCException<!
/literal> sont:"
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr "<literal>JDBCConnectionException</literal> - Indique une erreur de communication avec la couche JDBC sous-jacente."
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr "<literal>SQLGrammarException</literal> - Indique un problème de grammaire ou de syntaxe avec la requête SQL envoyée."
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr "<literal>ConstraintViolationException</literal> - Indique une violation de contrainte d'intégrité."
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "<literal>LockAcquisitionException</literal> - Indique une erreur de verrouillage lors de l'éxécution de la requête."
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr "<literal>GenericJDBCException</literal> - Indique une erreur générique JDBC d'une autre catégorie."
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr "Timeout de transaction"
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "L'un des avantages fournis par les environnements transactionnels JTA (tels les containers EJB) est la gestion du timeout de transaction. La gestion des dépassements de temps de transaction vise à s'assurer qu'une transaction agissant incorrectement ne viendra pas bloquer indéfiniment les ressources de l'application. Hibernate ne peut fournir cette fonctionnalité dans un environnement transactionnel non-JTA. Par contre, Hibernate gère les opérations d'accès aux données en allouant un temps maximal aux requêtes pour s'exécuter. Ainsi, une requête créant de l'inter blocage ou retournant de très grandes quantités d'information pourrait être interrompue. Dans un environnement transactionnel JTA, Hibernate peut déléguer au gestionnaire de transaction le soin de gérer les dépassements de temps. Cette fonctionnalité est abstraite par l'objet <literal>Transaction</literal> ."
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " Session sess = factory.openSession();\n"
+ " try {\n"
+ " //mettre le timeout à 3 secondes.\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // Effectuer le travail ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ " }\n"
+ " catch (RuntimeException e) {\n"
+ " if ( sess.getTransaction().isActive() ) {\n"
+ " sess.getTransaction().rollback();\n"
+ " }\n"
+ " throw e;\n"
+ " // ou afficher le message d'erreur.\n"
+ " }\n"
+ " finally {\n"
+ " sess.close();\n"
+ " }]]>"
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr "Notez que <literal>setTimeout()</literal> ne peut pas être appelé d'un EJB CMT, puisque le timeout des transaction doit être spécifié de manière déclarative."
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr "Contrôle de consurrence optimiste"
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "La gestion optimiste des accès concurrents avec versionnage est la seule approche pouvant garantir l'extensibilité des applications à haut niveau de charge. Le système de versionnage utilise des numéros de version ou l'horodatage pour détecter les mises à jour causant des conflits avec d'autres actualisations antérieures. Hibernate propose trois approches pour l'écriture de code applicatif utilisant la gestion optimiste d'accès concurrents. Le cas d'utilisation décrit plus bas fait mention de conversation, mais le versionnage peut également améliorer la qualité d'une application en prévenant la perte de mises à jour."
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr "Gestion du versionnage au niveau applicatif"
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr "Dans cet exemple d'implémentation utilisant peu les fonctionnalités d'Hibernate, chaque interaction avec la base de données se fait en utilisant une nouvelle <literal>Session</literal> et le développeur doit recharger les données persistantes à partir de la BD avant de les manipuler. Cette implémentation force l'application à vérifier la version des objets afin de maintenir l'isolation transactionnelle. Cette approche, semblable à celle retrouvée pour les EJB, est la moins efficace de celles présentées dans ce chapitre."
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[// foo est une instance chargée antérieurement par une autre\n"
+ " Session session = factory.openSession();\n"
+ " Transaction t = session.beginTransaction();\n"
+ "\n"
+ " int oldVersion = foo.getVersion();\n"
+ " session.load( foo, foo.getKey() ); // Charger l'état courant\n"
+ "\n"
+ " if ( oldVersion != foo.getVersion() )\n"
+ " throw new StaleObjectStateException();\n"
+ "\n"
+ " foo.setProperty(\"bar\");\n"
+ " t.commit();\n"
+ " session.close();]]>"
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr "Le mapping de la propriété <literal>version</literal> est fait via <literal><version></literal> et Hibernate l'incrémentera automatiquement à chaque flush() si l'entité doit être mise à jour."
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "Bien sûr, si votre application ne fait pas face à beaucoup d'accès concurrents et ne nécessite pas l'utilisation du versionnage, cette approche peut également être utilisée, il n'y a qu'à ignorer le code relié au versionnage. Dans ce cas, la stratégie du <emphasis>last commit wins</emphasis> (littéralement: le dernier commit l'emporte) sera utilisée pour les conversations (longues transactions applicatives). Gardez à l'esprit que cette approche pourrait rendre perplexe les utilisateurs de l'application car ils pourraient perdre des données mises à jour sans qu'aucun message d'erreur ne leur soit présenté et sans avoir la possibilité de fusionner les données."
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "Il est clair que la gestion manuelle de la vérification du versionnage des objets ne peut être effectuée que dans certains cas triviaux et que cette approche n'est pas valable pour la plupart des applications. De manière générale, les applications ne cherchent pas à actualiser de simples objets sans relations, elles le font généralement pour de larges graphes d'objets. Pour toute application utilisant le paradigme des conversations ou des objets détachés, Hibernate peut gérer automatiquement la vérification des versions d'objets."
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr "Les sessions longues et le versionnage automatique."
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr "Dans ce scénario, une seule instance de <literal>Session</literal> et des objets persistants est utilisée pour toute l'application. Hibernate vérifie la version des objets persistants avant d'effectuer le flush() et lance une exception si une modification concurrente est détectée. Il appartient alors au développeur de gérer l'exception. Les traitements alternatifs généralement proposés sont alors de permettre à l'usager de faire la fusion des données ou de lui offrir de recommencer son travail à partie des données les plus récentes dans la BD."
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr "Il est à noter que lorsqu'une application est en attente d'une action de la part de l?usager, La <literal>Session</literal> n'est pas connectée à la couche JDBC sous-jacente. C'est la manière la plus efficace de gérer les accès à la base de données. L'application ne devrait pas se préoccuper du versionnage des objets, de la réassociation des objets détachés, ni du rechargement de tous les objets à chaque transaction."
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr ""
+ "<![CDATA[// foo est une instance chargée antérieurement par une autre session\n"
+ "\n"
+ " session.reconnect();// Obtention d'une nouvelle connexion JDBC\n"
+ " Transaction t = session.beginTransaction();\n"
+ " foo.setProperty(\"bar\");\n"
+ " t.commit(); //Terminer la transaction, propager les changements et vérifier les versions.\n"
+ " session.disconnect(); // Retourner la connexion JDBC\n"
+ " ]]>"
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr "L'objet <literal>foo</literal> sait quel objet <literal>Session</literal> l'a chargé. <literal>Session.reconnect()</literal> obtient une nouvelle connexion (celle-ci peut être également fournie) et permet à la session de continuer son travail. La méthode <literal>Session.disconnect()</literal> déconnecte la session de la connexion JDBC et retourne celle-ci au pool de connexion (à moins que vous ne lui ayez fourni vous même la connexion.) Après la reconnexion, afin de forcer la vérification du versionnage de certaines entités que vous ne cherchez pas à actualiser, vous pouvez faire un appel à <literal>Session.lock()</literal> en mode <literal>LockMode.READ</literal> pour tout objet ayant pu être modifié par une autre transaction. Il n'est pas nécessaire de verrouiller les données que vous désirez mettre à jour."
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr "Si des appels implicites aux méthodes <literal>disconnect()</literal> et <literal>reconnect()</literal> sont trop coûteux, vous pouvez les éviter en utilisant <literal>hibernate.connection.release_mode</literal> ."
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr "Ce pattern peut présenter des problèmes si la <literal>Session</literal> est trop volumineuse pour être stockée entre les actions de l'usager. Plus spécifiquement, une session <literal>HttpSession</literal> se doit d'être la plus petite possible. Puisque la <literal>Session</literal> joue obligatoirement le rôle de mémoire cache de premier niveau et contient à ce titre tous les objets chargés, il est préférable de n'utiliser cette stratégie que pour quelques cycles de requêtes car les objets risquent d'y être rapidement périmés."
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr "Notez que la <literal>Session</literal> déconnectée devrait être conservée près de la couche de persistance. Autrement dit, utilisez un EJB stateful pour conserver la <literal>Session</literal> et évitez de la sérialiser et de la transférer à la couche de présentation (i.e. Il est préférable de ne pas la conserver dans la session <literal>HttpSession</literal> .)"
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr "Les objets détachés et le versionnage automatique"
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr "Chaque interaction avec le système de persistance se fait via une nouvelle <literal>Session</literal> . Toutefois, les mêmes instances d'objets persistants sont réutilisées pour chacune de ces interactions. L'application doit pouvoir manipuler l'état des instances détachées ayant été chargées antérieurement via une autre session. Pour ce faire, ces objets persistants doivent être rattachés à la <literal>Session</literal> courante en utilisant <literal>Session.update()</literal> , <literal>Session.saveOrUpdate()</literal> , ou <literal>Session.merge()</literal> ."
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr ""
+ "<![CDATA[// foo est une instance chargée antérieurement par une autre session\n"
+ "\n"
+ " foo.setProperty(\"bar\");\n"
+ " session = factory.openSession();\n"
+ " Transaction t = session.beginTransaction();\n"
+ " session.saveOrUpdate(foo); //Utiliser merge() si \"foo\" pourrait avoir été chargé précédement\n"
+ " t.commit();\n"
+ " session.close();]]>"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr "Encore une fois, Hibernate vérifiera la version des instances devant être actualisées durant le flush(). Une exception sera lancée si des conflits sont détectés."
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr "Vous pouvez également utiliser <literal>lock()</literal> au lieu de <literal>update()</literal> et utiliser le mode <literal>LockMode.READ</literal> (qui lancera une vérification de version, en ignorant tous les niveaux de mémoire cache) si vous êtes certain que l'objet n'a pas été modifié."
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr "Personnaliser le versionnage automatique"
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr "Vous pouvez désactiver l'incrémentation automatique du numéro de version de certains attributs et collections en mettant la valeur du paramètre de mapping <literal>optimistic-lock</literal> à false. Hibernate cessera ainsi d'incrémenter leur numéro de version s'ils sont mis à jour."
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "Certaines entreprises possèdent de vieux systèmes dont les schémas de bases de données sont statiques et ne peuvent être modifiés. Il existe aussi des cas où plusieurs applications doivent accéder à la même base de données, mais certaines d'entre elles ne peuvent gérer les numéros de version ou les champs horodatés. Dans les deux cas, le versionnage ne peut être implanté par le rajout d'une colonne dans la base de données. Afin de forcer la vérification de version dans un système sans en faire le mapping, mais en forçant une comparaison des états de tous les attributs d'une entité, vous pouvez utiliser l'attribut <literal>optimistic- lock=\"all\"</literal> sous l'élément <literal><class></literal> . Veuillez noter que cette manière de gérer le versionnage ne peut être utilisée que si l'application utilises de longues sessions, lui permettant de comparer l'ancien état et le nouvel état d'une entité. L'utilisation d'un pattern <lit!
eral>session-per-request-with-detached- objects</literal> devient alors impossible."
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr "Il peut être souhaitable de permettre les modifications concurrentes lorsque des champs distincts sont modifiés. En mettant la propriété <literal>optimistic-lock=\"dirty\"</literal> dans l'élément <literal><class></literal> , Hibernate ne fera la comparaison que des champs devant être actualisés lors du flush()."
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr "Dans les deux cas: en utilisant une colonne de version/horodatée ou via la comparaison de l'état complet de l'objet ou de ses champs modifiés, Hibernate ne créera qu'une seule commande d'UPDATE par entité avec la clause WHERE appropriée pour mettre à jour l'entité <emphasis>ET</emphasis> en vérifier la version. Si vous utilisez la persistance transitive pour propager l'évènement de rattachement à des entités associées, il est possible qu'Hibernate génère des commandes d'UPDATE inutiles. Ceci n'est généralement pas un problème, mais certains déclencheurs <emphasis>on update</emphasis> dans la base de données pourraient être activés même si aucun changement n'était réellement persisté sur des objets associés. Vous pouvez personnaliser ce comportement en indiquant <literal>select-before- update=\"true\"</literal> dans l'élément de mapping <literal><class></literal> . Ceci forcera Hibernate à faire le SELECT de l'instance afin de s'a!
ssurer que l'entité doit réellement être actualisée avant de lancer la commande d'UPDATE."
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr "Verouillage pessimiste"
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr "Il n'est nécessaire de s'attarder à la stratégie de verrouillage des entités dans une application utilisant Hibernate. Il est généralement suffisant de définir le niveau d'isolation pour les connexions JDBC et de laisser ensuite la base de donnée effectuer son travail. Toutefois, certains utilisateurs avancés peuvent vouloir obtenir un verrouillage pessimiste exclusif sur un enregistrement et le réobtenir au lancement d'une nouvelle transaction."
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr "Hibernate utilisera toujours le mécanisme de verrouillage de la base de données et ne verrouillera jamais les objets en mémoire!"
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr "La classe <literal>LockMode</literal> définit les différents niveaux de verrouillage pouvant être obtenus par Hibernate. Le verrouillage est obtenu par les mécanismes suivants:"
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "<literal>LockMode.WRITE</literal> est obtenu automatiquement quand Hibernate actualise ou insert un enregistrement."
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "<literal>LockMode.UPGRADE</literal> peut être obtenu de manière explicite via la requête en utilisant <literal>SELECT ... FOR UPDATE</literal> sur une base de données supportant cette syntaxe."
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "<literal>LockMode.UPGRADE_NOWAIT</literal> peut être obtenu de manière explicite en utilisant <literal>SELECT ... FOR UPDATE NOWAIT</literal> sur Oracle."
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "<literal>LockMode.READ</literal> est obtenu automatiquement quand Hibernate lit des données dans un contexte d'isolation <literal>Repeatable Read</literal> ou <literal>Serializable</literal> . Peut être réobtenu explicitement via une requête."
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr "<literal>LockMode.NONE</literal> représente l'absence de verouillage. Tous les objets migrent vers ce mode a la fin d'une <literal>Transaction</literal> . Les objets associés à une session via un appel à <literal>saveOrUpdate()</literal> commencent également leur cycle de vie dans cet état."
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr "Les niveaux de verrouillage peuvent être explicitement obtenus de l'une des manières suivantes:"
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr "Un appel à <literal>Session.load()</literal> , en spécifiant un niveau verrouillage <literal>LockMode</literal> ."
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr "Un appel à <literal>Session.lock()</literal> ."
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr "Une appel à <literal>Query.setLockMode()</literal> ."
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr "Si <literal>Session.load()</literal> est appelé avec le paramètre de niveau de verouillage <literal>UPGRADE</literal> ou <literal>UPGRADE_NOWAIT</literal> et que l'objet demandé n'est pas présent dans la session, celui-ci sera chargé à l'aide d'une requête <literal>SELECT ... FOR UPDATE</literal> . Si la méthode <literal>load()</literal> est appelée pour un objet déjà en session avec un verrouillage moindre que celui demandé, Hibernate appellera la méthode <literal>lock()</literal> pour cet objet."
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr "<literal>Session.lock()</literal> effectue une vérification de version si le niveau de verrouillage est <literal>READ</literal> , <literal>UPGRADE</literal> ou <literal>UPGRADE_NOWAIT</literal> . (Dans le cas des niveaux <literal>UPGRADE</literal> ou <literal>UPGRADE_NOWAIT</literal> , une requête <literal>SELECT ... FOR UPDATE</literal> sera utilisée.)"
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr "Si une base de données ne supporte pas le niveau de verrouillage demandé, Hibernate utilisera un niveau alternatif convenable au lieux de lancer une exception. Ceci assurera la portabilité de votre application."
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr "Mode de libération de Connection"
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr "Le comportement original (2.x) d'Hibernate pour la gestion des connexions JDBC était que la <literal>Session</literal> obtenait une connexion dès qu'elle en avait besoin et la libérait une fois la session fermée. Hibernate 3 a introduit les modes de libération de connexion pour indiquer à la session comment gérer les transactions JDBC. Notez que la discussion suivante n'est pertinente que pour des connexions fournies par un <literal>ConnectionProvider</literal>, celles gérées par l'utilisateur sont en dehors du scope de cette discussion. Les différents modes sont définies par <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr "<literal>ON_CLOSE</literal> - est essentiellement le comportement passé. La session Hibernate obtient une connexion lorsqu'elle en a besoin et la garde jusqu'à ce que la session se ferme."
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr "<literal>AFTER_TRANSACTION</literal> - indique de relacher la connexion après qu'une <literal>org.hibernate.Transaction</literal> se soit achevée."
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr "<literal>AFTER_STATEMENT</literal> (aussi appelé libération brutale) - indique de relacher les connexions après chaque exécution d'un statement. Ce relachement aggressif est annulé si ce statement laisse des ressources associées à une session donnée ouvertes, actuellement ceci n'arrive que lors de l'utilisation de <literal>org.hibernate.ScrollableResults</literal>."
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr "Le paramètre de configuration <literal>hibernate.connection.release_mode</literal> est utilisé pour spécifier quel mode de libération doit être utiliser. Les valeurs possibles sont:"
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr "<literal>auto</literal> (valeur par défaut) - ce choix délègue le choix de libération à la méthode <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> Pour la JTATransactionFactory, elle retourne ConnectionReleaseMode.AFTER_STATEMENT; pour JDBCTransactionFactory, elle retourne ConnectionReleaseMode.AFTER_TRANSACTION. C'est rarement une bonne idée de changer ce comportement par défaut puisque les erreurs soulevées par ce paramétrage tend à prouver une erreur dans le code de l'utilisateur."
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr "<literal>on_close</literal> - indique d'utiliser ConnectionReleaseMode.ON_CLOSE. Ce paramétrage existe pour garantir la compatibilité avec les versions précédentes, mais ne devrait plus être utilisé."
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr "<literal>after_transaction</literal> - indique d'utiliser ConnectionReleaseMode.AFTER_TRANSACTION. Ne devrait pas être utilisé dans les environnements JTA. Notez aussi qu'avec ConnectionReleaseMode.AFTER_TRANSACTION, si une session est considérée comme étant en mode auto-commit les connexions seront relachées comme si le mode était AFTER_STATEMENT."
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr "<literal>after_statement</literal> - indique d'utiliser ConnectionReleaseMode.AFTER_STATEMENT. Additonnellement, le <literal>ConnectionProvider</literal> utilisé est consulté pour savoir s'il supporte ce paramétrage (<literal>supportsAggressiveRelease()</literal>). Si ce n'est pas le cas, le mode de libération est ré initialisé à ConnectionReleaseMode.AFTER_TRANSACTION. Ce paramétrage n'est sûr que dans les environnements où il est possible d'obtenir à nouveau la même connexion JDBC à chaque fois que l'on fait un appel de <literal>ConnectionProvider.getConnection()</literal> ou dans les envrionnements auto-commit où il n'est pas important d'obtenir plusieurs fois la même connexion."
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1891 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr "Introduction à Hibernate"
+
+#: index.docbook:10
+msgid "Preface"
+msgstr "Préface"
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr "Ce chapitre est un didacticiel introductif destiné aux nouveaux utilisateurs d'Hibernate. Nous commençons avec une simple application en ligne de commande utilisant une base de données en mémoire, et la développons en étapes faciles à comprendre."
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr "Ce didacticiel est destiné aux nouveaux utilisateurs d'Hibernate mais requiert des connaissances Java et SQL. Il est basé sur un didacticiel de Michael Gloegl, les bibliothèques tierces que nous nommons sont pour les JDK 1.4 et 5.0. Vous pourriez avoir besoin d'autres bibliothèques pour le JDK 1.3."
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "Le code source de ce tutoriel est inclus dans la distribution dans le répertoire <literal>doc/reference/tutorial/</literal>."
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr "Partie 1 - Première application Hibernate"
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr "D'abord, nous créerons une simple application Hibernate en console. Nous utilisons une base de données en mémoire (HSQL DB), donc nous n'avons pas à installer de serveur de base de données."
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr "Supposons que nous ayons besoin d'une petite application de base de données qui puisse stocker des événements que nous voulons suivre, et des informations à propos des hôtes de ces événements."
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr "La première chose que nous faisons est de configurer notre répertoire de développement et de mettre toutes les bibliothèques dont nous avons besoin dedans. Téléchargez la distribution Hibernate à partir du site web d'Hibernate. Extrayez le paquet et placez toutes les bibliothèques requises trouvées dans <literal>/lib</literal> dans le répertoire <literal>/lib</literal> de votre nouveau répertoire de travail. Il devrait ressembler à ça :"
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib-full.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " ehcache.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr "Ceci est l'ensemble minimum de bibliothèques requises (notez que nous avons aussi copié hibernate3.jar, l'archive principale) pour Hibernate. Lisez le fichier <literal>README.txt</literal> dans le répertoire <literal>lib/</literal> de la distribution Hibernate pour plus d'informations à propos des biliothèques tierces requises et optionnelles. (En fait, log4j n'est pas requis mais préféré par beaucoup de développeurs.)"
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr "Ensuite, nous créons une classe qui réprésente l'événement que nous voulons stocker dans notre base de données."
+
+#: index.docbook:68
+msgid "The first class"
+msgstr "La première classe"
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr "Notre première classe persistante est une simple classe JavaBean avec quelques propriétés :"
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr "Vous pouvez voir que cette classe utilise les conventions de nommage standard JavaBean pour les méthodes getter/setter des propriétés, ainsi qu'une visibilité privée pour les champs. Ceci est la conception recommandée - mais pas obligatoire. Hibernate peut aussi accéder aux champs directement, le bénéfice des méthodes d'accès est la robustesse pour la refonte de code. Le constructeur sans argument est requis pour instancier un objet de cette classe via reflexion."
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr "La propriété <literal>id</literal> contient la valeur d'un identifiant unique pour un événement particulier. Toutes les classes d'entités persistantes (ainsi que les classes dépendantes de moindre importance) auront besoin d'une telle propriété identifiante si nous voulons utiliser l'ensemble complet des fonctionnalités d'Hibernate. En fait, la plupart des applications (surtout les applications web) ont besoin de distinguer des objets par des identifiants, donc vous devriez considérer ça comme une fonctionnalité plutôt que comme une limitation. Cependant, nous ne manipulons généralement pas l'identité d'un objet, dorénavant la méthode setter devrait être privée. Seul Hibernate assignera les identifiants lorsqu'un objet est sauvegardé. Vous pouvez voir qu'Hibernate peut accéder aux méthodes publiques, privées et protégées, ainsi qu'aux champs (publics, privés, protégés) directement. Le choix vous est laissé, et vous pouvez l'ajuster à l!
a conception de votre application."
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr "Le constructeur sans argument est requis pour toutes les classes persistantes ; Hibernate doit créer des objets pour vous en utilisant la réflexion Java. Le constructeur peut être privé, cependant, la visibilité du paquet est requise pour la génération de proxy à l'exécution et une récupération des données efficaces sans instrumentation du bytecode."
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr "Placez ce fichier source Java dans un répertoire appelé <literal>src</literal> dans le dossier de développement. Ce répertoire devrait maintenant ressembler à ça :"
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate et bibliothèques tierces>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr "Dans la prochaine étape, nous informons Hibernate de cette classe persistante."
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr "Le fichier de mapping"
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr "Hibernate a besoin de savoir comment charger et stocker des objets d'une classe persistante. C'est là qu'intervient le fichier de mapping Hibernate. Le fichier de mapping indique à Hibernate à quelle table dans la base de données il doit accéder, et quelles colonnes de cette table il devra utiliser."
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr "La structure basique de ce fichier de mapping ressemble à ça :"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr "Notez que la DTD Hibernate est très sophistiquée. Vous pouvez l'utiliser pour l'auto-complétement des éléments et des attributs de mapping XML dans votre éditeur ou votre IDE. Vous devriez aussi ouvrir le fichier DTD dans votre éditeur de texte - c'est le moyen le plus facile d'obtenir une vue d'ensemble de tous les éléments et attributs, et de voir les valeurs par défaut, ainsi que quelques commentaires. Notez qu'Hibernate ne chargera pas le fichier DTD à partir du web, mais regardera d'abord dans le classpath de l'application. Le fichier DTD est inclus dans <literal>hibernate3.jar</literal> ainsi que dans le répertoire <literal>src</literal> de la distribution Hibernate."
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr "Nous omettrons la déclaration de la DTD dans les exemples futurs pour raccourcir le code. Bien sûr il n'est pas optionnel."
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr "Entre les deux balises <literal>hibernate-mapping</literal>, incluez un élément <literal>class</literal>. Toutes les classes d'entités persistantes (encore une fois, il pourrait y avoir des classes dépendantes plus tard, qui ne sont pas des entités mère) ont besoin d'un mapping vers une table de la base de données SQL :"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr "Plus loin, nous disons à Hibernate comment persister et charger un objet de la classe <literal>Event</literal> dans la table <literal>EVENTS</literal>, chaque instance est représentée par une ligne dans cette table. Maintenant nous continuons avec le mapping de la propriété de l'identifiant unique vers la clef primaire de la table. De plus, comme nous ne voulons pas nous occuper de la gestion de cet identifiant, nous utilisons une stratégie de génération d'identifiant d'Hibernate pour la colonne de la clef primaire subrogée :"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr "L'élément <literal>id</literal> est la déclaration de la propriété de l'identifiant, <literal>name=\"id\"</literal> déclare le nom de la propriété Java - Hibernate utilisera les méthodes getter et setter pour accéder à la propriété. L'attribut <literal>column</literal> indique à Hibernate quelle colonne de la table <literal>EVENTS</literal> nous utilisons pour cette clef primaire. L'élément <literal>generator</literal> imbriqué spécifie la stratégie de génération de l'identifiant, dans ce cas nous avons utilisé <literal>increment</literal>, laquelle est une méthode très simple utile surtout pour les tests (et didacticiels). Hibernate supporte aussi les identifiants générés par les bases de données, globalement uniques, ainsi que les identifiants assignés par l'application (ou n'importe quelle stratégie que vous avez écrit en extension)."
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr "Finalement nous incluons des déclarations pour les propriétés persistantes de la classe dans le fichier de mapping. Par défaut, aucune propriété de la classe n'est considérée comme persistante :"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr "Comme avec l'élément <literal>id</literal>, l'attribut <literal>name</literal> de l'élément <literal>property</literal> indique à Hibernate quels getters/setters utiliser."
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr "Pourquoi le mapping de la propriété <literal>date</literal> inclut l'attribut <literal>column</literal>, mais pas <literal>title</literal> ? Sans l'attribut <literal>column</literal> Hibernate utilise par défaut le nom de la propriété comme nom de colonne. Ca fonctionne bien pour <literal>title</literal>. Cependant, <literal>date</literal> est un mot clef réservé dans la plupart des bases de données, donc nous utilisons un nom différent pour le mapping."
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr "La prochaine chose intéressante est que le mapping de <literal>title</literal> manque aussi d'un attribut <literal>type</literal>. Les types que nous déclarons et utilisons dans les fichiers de mapping ne sont pas, comme vous pourriez vous y attendre, des types de données Java. Ce ne sont pas, non plus, des types de base de données SQL. Ces types sont donc appelés des <emphasis>types de mapping Hibernate</emphasis>, des convertisseurs qui peuvent traduire des types Java en types SQL et vice versa. De plus, Hibernate tentera de déterminer la bonne conversion et le type de mapping lui-même si l'attribut <literal>type</literal> n'est pas présent dans le mapping. Dans certains cas, cette détection automatique (utilisant la réflexion sur la classe Java) pourrait ne pas donner la valeur attendue ou dont vous avez besoin. C'est le cas avec la propriété <literal>date</literal>. Hibernate ne peut pas savoir si la propriété \"mappera\" une colonne SQL de type <l!
iteral>date</literal>, <literal>timestamp</literal> ou <literal>time</literal>. Nous déclarons que nous voulons conserver des informations avec une date complète et l'heure en mappant la propriété avec un <literal>timestamp</literal>."
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr "Ce fichier de mapping devrait être sauvegardé en tant que <literal>Event.hbm.xml</literal>, juste dans le répertoire à côté du fichier source de la classe Java <literal>Event</literal>. Le nommage des fichiers de mapping peut être arbitraire, cependant le suffixe <literal>hbm.xml</literal> est devenu une convention dans la communauté des développeurs Hibernate. La structure du répertoire devrait ressembler à ça :"
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate et bibliothèques tierces>\n"
+ "+src\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr "Nous poursuivons avec la configuration principale d'Hibernate."
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr "Configuration d'Hibernate"
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr "Nous avons maintenant une classe persistante et son fichier de mapping. Il est temps de configurer Hibernate. Avant ça, nous avons besoin d'une base de données. HSQL DB, un SGBD SQL basé sur Java et travaillant en mémoire, peut être téléchargé à partir du site web de HSQL. En fait, vous avez seulement besoin de <literal>hsqldb.jar</literal>. Placez ce fichier dans le répertoire <literal>lib/</literal> du dossier de développement."
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr "Créez un répertoire appelé <literal>data</literal> à la racine du répertoire de développement - c'est là que HSQL DB stockera ses fichiers de données. Démarrez maintenant votre base de données en exécutant <literal>java -classpath lib/hsqldb.jar org.hsqldb.Server</literal> dans votre répertoire de travail. Vous observez qu'elle démarre et ouvre une socket TCP/IP, c'est là que notre application se connectera plus tard. Si vous souhaitez démarrez à partir d'une nouvelle base de données pour ce tutoriel (faites <literal>CTRL + C</literal> dans la fenêtre the window), effacez le répertoire <literal>data/</literal> et redémarrez HSQL DB à nouveau."
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr "Hibernate est la couche de votre application qui se connecte à cette base de données, donc il a besoin des informations de connexion. Les connexions sont établies à travers un pool de connexions JDBC, que nous devons aussi configurer. La distribution Hibernate contient différents outils de gestion de pools de connexions JDBC open source, mais pour ce didacticiel nous utiliserons le pool de connexions intégré à Hibernate. Notez que vous devez copier les bibliothèques requises dans votre classpath et utiliser une configuration de pool de connexions différente si vous voulez utiliser un logiciel de gestion de pools JDBC tiers avec une qualité de production."
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr "Pour la configuration d'Hibernate, nous pouvons utiliser un simple fichier <literal>hibernate.properties</literal>, un fichier <literal>hibernate.cfg.xml</literal> légèrement plus sophistiqué, ou même une configuration complète par programmation. La plupart des utilisateurs préfèrent le fichier de configuration XML :"
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr "Notez que cette configuration XML utilise une DTD différente. Nous configurons une <literal>SessionFactory</literal> d'Hibernate - une fabrique globale responsable d'une base de données particulière. Si vous avez plusieurs base de données, utilisez plusieurs configurations <literal><session-factory></literal>, généralement dans des fichiers de configuration différents (pour un démarrage plus facile)."
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr "Les quatre premiers éléments <literal>property</literal> contiennent la configuration nécessaire pour la connexion JDBC. L'élément <literal>property</literal> du dialecte spécifie quelle variante du SQL Hibernate va générer. La gestion automatique des sessions d'Hibernate pour les contextes de persistance sera détaillée très vite. L'option <literal>hbm2ddl.auto</literal> active la génération automatique des schémas de base de données - directement dans la base de données. Cela peut bien sûr aussi être désactivé (en supprimant l'option de configuration) ou redirigé vers un fichier avec l'aide de la tâche Ant <literal>SchemaExport</literal>. Finalement, nous ajoutons le(s) fichier(s) de mapping pour les classes persistantes."
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr "Copiez ce fichier dans le répertoire source, il terminera dans la racine du classpath. Hibernate cherchera automatiquement, au démarrage, un fichier appelé <literal>hibernate.cfg.xml</literal> dans la racine du classpath."
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr "Construction avec Ant"
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr "Nous allons maintenant construire le didacticiel avec Ant. Vous aurez besoin d'avoir Ant d'installé - récupérez-le à partir de <ulink url=\"http://ant.apache.org/bindownload.cgi\"> la page de téléchargement de Ant</ulink>. Comment installer Ant ne sera pas couvert ici. Référez-vous au <ulink url=\"http://ant.apache.org/manual/index.html\">manuel d'Ant</ulink>. Après que vous aurez installé Ant, nous pourrons commencer à créer le fichier de construction. Il s'appellera <literal>build.xml</literal> et sera placé directement dans le répertoire de développement."
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr "Un fichier de construction basique ressemble à ça :"
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr "Cela dira à Ant d'ajouter tous les fichiers du répertoire lib finissant par <literal>.jar</literal> dans le classpath utilisé pour la compilation. Cela copiera aussi tous les fichiers source non Java dans le répertoire cible, par exemple les fichiers de configuration et de mapping d'Hibernate. Si vous lancez Ant maintenant, vous devriez obtenir cette sortie :"
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr "Démarrage et aides"
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr "Il est temps de charger et de stocker quelques objets <literal>Event</literal>, mais d'abord nous devons compléter la configuration avec du code d'infrastructure. Nous devons démarrer Hibernate. Ce démarrage inclut la construction d'un objet <literal>SessionFactory</literal> global et le stocker quelque part facile d'accès dans le code de l'application. Une <literal>SessionFactory</literal> peut ouvrir des nouvelles <literal>Session</literal>s. Une <literal>Session</literal> représente une unité de travail simplement \"threadée\", la <literal>SessionFactory</literal> est un objet global \"thread-safe\", instancié une seule fois."
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr "Nous créerons une classe d'aide <literal>HibernateUtil</literal> qui s'occupe du démarrage et rend la gestion des <literal>Session</literal>s plus facile. Regardons l'implémentation :"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ " public static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Création de la SessionFactory à partir de hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static final ThreadLocal session = new ThreadLocal();\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr "Cette classe ne produit pas seulement la <literal>SessionFactory</literal> globale dans un initialiseur statique (appelé une seule fois par la JVM lorsque la classe est chargée), elle masque le fait qu'elle exploite un singleton. Elle pourrait aussi obtenir la <literal>SessionFactory</literal> depuis JNDI dans un serveur d'applications."
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr "Si vous nommez la <literal>SessionFactory</literal> dans votre fichier de configuration, Hibernate tentera la récupération depuis JNDI. Pour éviter ce code, vous pouvez aussi utiliser un déploiement JMX et laisser le conteneur (compatible JMX) instancier et lier un <literal>HibernateService</literal> à JNDI. Ces options avancées sont détaillées dans la documentation de référence Hibernate."
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr "Placez <literal>HibernateUtil.java</literal> dans le répertoire source de développement, et ensuite <literal>Event.java</literal> :"
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr "Cela devrait encore compiler sans problème. Nous avons finalement besoin de configurer le système de \"logs\" - Hibernate utilise commons-logging et vous laisse le choix entre log4j et le système de logs du JDK 1.4. La plupart des développeurs préfèrent log4j : copiez <literal>log4j.properties</literal> de la distribution d'Hibernate (il est dans le répertoire <literal>etc/</literal>) dans votre répertoire <literal>src</literal>, puis faites de même avec <literal>hibernate.cfg.xml</literal>. Regardez la configuration d'exemple et changez les paramètres si vous voulez une sortie plus verbeuse. Par défaut, seul le message de démarrage d'Hibernate est affiché sur la sortie standard."
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr "L'infrastructure de ce didacticiel est complète - et nous sommes prêts à effectuer un travail réel avec Hibernate."
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr "Charger et stocker des objets"
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr "Finalement nous pouvons utiliser Hibernate pour charger et stocker des objets. Nous écrivons une classe <literal>EventManager</literal> avec une méthode <literal>main()</literal> :"
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }]]>"
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr "Nous créons un nouvel objet <literal>Event</literal>, et le remettons à Hibernate. Hibernate s'occupe maintenant du SQL et exécute les <literal>INSERT</literal>s dans la base de données. Regardons le code de gestion de la <literal>Session</literal> et de la <literal>Transaction</literal> avant de lancer ça."
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr "Une <literal>Session</literal> est une unité de travail. Pour le moment, nous allons faire les choses simplement et assumer une granularité un-un entre une <literal>Session</literal> hibernate et une transaction à la base de données. Pour isoler notre code du système de transaction sous-jacent (dans notre cas, du pure JDBC, mais cela pourrait être JTA), nous utilisons l'API <literal>Transaction</literal> qui est disponible depuis la <literal>Session</literal> Hibernate."
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr "Que fait <literal>sessionFactory.getCurrentSession()</literal> ? Premièrement, vous pouvez l'invoquer autant de fois que vous le voulez et n'importe où du moment que vous avez votre <literal>SessionFactory</literal> (facile grâce à <literal>HibernateUtil</literal>). La méthode <literal>getCurrentSession()</literal> renvoie toujours l'unité de travail courante. Souvenez vous que nous avons basculé notre option de configuration au mécanisme basé sur le \"thread\" dans <literal>hibernate.cfg.xml</literal>. Par conséquent, le scope de l'unité de travail courante est le thread java courant d'exécution. Ceci n'est pas totalement vrai. Une <literal>Session</literal> commence lorsqu'elle est vraiment utilisée la première fois, Lorsque nous appelons pour la première fois <literal>getCurrentSession()</literal>. Ensuite, elle est liée, par Hibernate, au thread courant. Lorsque la transaction s'achève (commit ou rollback), Hibernate délie la <literal>Session</!
literal> du thread et la ferme pour vous. Si vous invoquez <literal>getCurrentSession()</literal> une autre fois, vous obtenez une nouvelle <literal>Session</literal> et pouvez entamer une nouvelle unité de travail. Ce modèle de programmation \"<emphasis>thread-bound</emphasis>\" est le moyen le plus populaire d'utiliser Hibernate."
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr "Lisez <xref linkend=\"transactions\"/> pour plus d'informations sur la gestion des transactions et leur démarcations. Nous n'avons pas géré les erreurs et rollback sur l'exemple précédent."
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr "Pour lancer cette première routine, nous devons ajouter une cible appelable dans le fichier de construction de Ant :"
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr "La valeur de l'argument <literal>action</literal> correspond à la ligne de commande qui appelle la cible :"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr "Vous devriez voir, après la compilation, Hibernate démarrer et, en fonction de votre configuration, beaucoup de traces sur la sortie. À la fin vous trouverez la ligne suivante :"
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr "C'est l'<literal>INSERT</literal> exécuté par Hibernate, les points d'interrogation représentent les paramètres JDBC liés. Pour voir les valeurs liées aux arguments, ou pour réduire la verbosité des traces, vérifier votre <literal>log4j.properties</literal>."
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr "Maintenant nous aimerions aussi lister les événements stockés, donc nous ajoutons une option à la méthode principale :"
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr "Nous ajoutons aussi une nouvelle méthode <literal>listEvents()</literal> :"
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr "Ce que nous faisons ici c'est utiliser une requête HQL (Hibernate Query Language) pour charger tous les objets <literal>Event</literal> existants de la base de données. Hibernate générera le SQL approprié, l'enverra à la base de données et peuplera des objets <literal>Event</literal> avec les données. Vous pouvez créer des requêtes plus complexes avec HQL, bien sûr."
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr "Maintenant, pour exécuter et tester tout ça, suivez ces étapes :"
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr "Exécutez <literal>ant run -Daction=store</literal> pour stocker quelque chose dans la base de données et, bien sûr, pour générer, avant, le schéma de la base de données grâce à hbm2ddl."
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr "Maintenant désactivez hbm2ddl en commentant la propriété dans votre fichier <literal>hibernate.cfg.xml</literal>. Généralement vous la laissez seulement activée dans des tests unitaires en continu, mais une autre exécution de hbm2ddl <emphasis>effacerait</emphasis> tout ce que vous avez stocké - le paramètre de configuration <literal>create</literal> se traduit en fait par \"supprimer toutes les tables du schéma, puis re-créer toutes les tables, lorsque la SessionFactory est construite\"."
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr "Si maintenant vous appelez Ant avec <literal>-Daction=list</literal>, vous devriez voir les événements que vous avez stockés jusque là . Vous pouvez bien sûr aussi appeler l'action <literal>store</literal> plusieurs fois."
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr "Partie 2 - Mapper des associations"
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr "Nous avons mappé une classe d'une entité persistante vers une table. Partons de là et ajoutons quelques associations de classe. D'abord nous ajouterons des gens à notre application, et stockerons une liste d'événements auxquels ils participent."
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr "Mapper la classe Person"
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr "La première version de la classe <literal>Person</literal> est simple :"
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr "Créez un nouveau fichier de mapping appelé <literal>Person.hbm.xml</literal> (n'oubliez pas la référence à la DTD)"
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr "Finalement, ajoutez la nouveau mapping à la configuration d'Hibernate :"
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "Nous allons maintenant créer une association entre ces deux entités. Évidemment, des personnes peuvent participer aux événements, et des événements ont des participants. Les questions de conception que nous devons traiter sont : direction, cardinalité et comportement de la collection."
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr "Une association unidirectionnelle basée sur Set"
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr "Nous allons ajouter une collection d'événements à la classe <literal>Person</literal>. De cette manière nous pouvons facilement naviguer dans les événements d'une personne particulière, sans exécuter une requête explicite - en appelant <literal>aPerson.getEvents()</literal>. Nous utilisons une collection Java, un <literal>Set</literal>, parce que la collection ne contiendra pas d'éléments dupliqués et l'ordre ne nous importe pas."
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr "Nous avons besoin d'une association unidirectionnelle, pluri-valuée, implémentée avec un <literal>Set</literal>. Écrivons le code pour ça dans les classes Java et mappons les :"
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr "D'abord nous mappons cette association, mais pensez à l'autre côté. Clairement, nous pouvons la laisser unidirectionnelle. Ou alors, nous pourrions créer une autre collection sur <literal>Event</literal>, si nous voulons être capable de la parcourir de manière bidirectionnelle, c'est-à -dire avoir <literal>anEvent.getParticipants()</literal>. Ce n'est pas nécessaire d'un point de vue fonctionnel. Vous pourrez toujours exécuter une requête explicite pour récupérer les participants d'un \"event\" particulier. Ce choix de conception vous est laissé, mais ce qui reste certains est la cardinalité de l'association: \"plusieurs\" des deux côtés, nous appelons cela une association <emphasis>many-to-many</emphasis>. Par conséquent nous utilisons un mapping Hibernate many-to-many:"
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr "Hibernate supporte toutes sortes de mapping de collection, un <literal><set></literal> étant le plus commun. Pour une association many-to-many (ou une relation d'entité <emphasis>n:m</emphasis>), une table d'association est requise. Chaque ligne dans cette table représente un lien entre une personne et un événement. Le nom de la table est configuré avec l'attribut <literal>table</literal> de l'élément <literal>set</literal>. Le nom de la colonne identifiant dans l'association, du côté de la personne, est défini avec l'élément <literal><key></literal>, et le nom de la colonne pour l'événement dans l'attribut <literal>column</literal> de <literal><many-to-many></literal>. Vous devez aussi donner à Hibernate la classe des objets de votre collection (c'est-à -dire : la classe de l'autre côté de la collection)."
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr "Le schéma de base de données pour ce mapping est donc :"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr "Travailler avec l'association"
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr "Réunissons quelques personnes et quelques événements dans une nouvelle méthode dans <literal>EventManager</literal> :"
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr "Après le chargement d'une <literal>Person</literal> et d'un <literal>Event</literal>, modifiez simplement la collection en utilisant les méthodes normales de la collection. Comme vous pouvez le voir, il n'y a pas d'appel explicite à <literal>update()</literal> ou <literal>save()</literal>, Hibernate détecte automatiquement que la collection a été modifiée et a besoin d'être mise à jour. Ceci est appelé <emphasis>la vérification sale automatique</emphasis> (NdT : \"automatic dirty checking\"), et vous pouvez aussi l'essayer en modifiant le nom ou la propriété date de n'importe lequel de vos objets. Tant qu'ils sont dans un état <emphasis>persistant</emphasis>, c'est-à -dire, liés à une <literal>Session</literal> Hibernate particulière (c-à -d qu'ils ont juste été chargés ou sauvegardés dans une unité de travail), Hibernate surveille les changements et exécute le SQL correspondant. Le processus de synchronisation de l'état de la mémoire avec l!
a base de données, généralement seulement à la fin d'une unité de travail, est appelé <emphasis>flushing</emphasis>. Dans notre code, l'unité de travail s'achève par un commit (ou rollback) de la transaction avec la base de données - comme défini par notre option <literal>thread</literal> de configuration pour la classe <literal>CurrentSessionContext</literal>."
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr "Vous pourriez bien sûr charger une personne et un événement dans différentes unités de travail. Ou vous modifiez un objet à l'extérieur d'une <literal>Session</literal>, s'il n'est pas dans un état persistant (s'il était persistant avant, nous appelons cet état <emphasis>détaché</emphasis>). Vous pouvez même modifier une collection lorsqu'elle est détachée:"
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr "L'appel à <literal>update</literal> rend un objet détaché à nouveau persistant, vous pourriez dire qu'il le lie à une unité de travail, ainsi toutes les modifications (ajout, suppression) que vous avez faites pendant qu'il était détaché peuvent être sauvegardées dans la base de données (il se peut que vous ayez besoin de modifier quelques unes des méthodes précédentes pour retourner cet identifiant)."
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);]]>"
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr "Ce n'est pas très utile dans notre situation actuelle, mais c'est un concept important que vous pouvez mettre dans votre propre application. Pour le moment, complétez cet exercice en ajoutant une nouvelle action à la méthode principale des <literal>EventManager</literal>s et appelez la à partir de la ligne de commande. Si vous avez besoin des identifiants d'une personne et d'un événement - la méthode <literal>save()</literal> les retourne."
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr "C'était un exemple d'une association entre deux classes de même importance, deux entités. Comme mentionné plus tôt, il y a d'autres classes et d'autres types dans un modèle typique, généralement \"moins importants\". Vous en avez déjà vu certains, comme un <literal>int</literal> ou une <literal>String</literal>. Nous appelons ces classes des <emphasis>types de valeur</emphasis>, et leurs instances <emphasis>dépendent</emphasis> d'une entité particulière. Des instances de ces types n'ont pas leur propre identité, elles ne sont pas non plus partagées entre des entités (deux personnes ne référencent pas le même objet <literal>firstname</literal>, même si elles ont le même prénom). Bien sûr, des types de valeur ne peuvent pas seulement être trouvés dans le JDK (en fait, dans une application Hibernate toutes les classes du JDK sont considérées comme des types de valeur), vous pouvez aussi écrire vous-même des classes dépendantes, <literal>Ad!
dress</literal> ou <literal>MonetaryAmount</literal>, par exemple."
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr "Vous pouvez aussi concevoir une collection de types de valeur. C'est conceptuellement très différent d'une collection de références vers d'autres entités, mais très ressemblant en Java."
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr "Collection de valeurs"
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr "Nous ajoutons une collection d'objets de type de valeur à l'entité <literal>Person</literal>. Nous voulons stocker des adresses email, donc le type que nous utilisons est <literal>String</literal>, et la collection est encore un <literal>Set</literal> :"
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr "Le mapping de ce <literal>Set</literal> :"
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr "La différence comparée au mapping vu plus tôt est la partie <literal>element</literal>, laquelle dit à Hibernate que la collection ne contient pas de références vers une autre entité, mais une collection d'éléments de type <literal>String</literal> (le nom en minuscule vous indique que c'est un type/convertisseur du mapping Hibernate). Une fois encore, l'attribut <literal>table</literal> de l'élément <literal>set</literal> détermine le nom de la table pour la collection. L'élément <literal>key</literal> définit le nom de la colonne de la clef étrangère dans la table de la collection. L'attribut <literal>column</literal> dans l'élément <literal>element</literal> définit le nom de la colonne où les valeurs de <literal>String</literal> seront réellement stockées."
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr "Regardons le schéma mis à jour :"
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr "Vous pouvez voir que la clef primaire de la table de la collection est en fait une clef composée, utilisant deux colonnes. Ceci implique aussi qu'il ne peut pas y avoir d'adresses email dupliquées par personne, ce qui est exactement la sémantique dont nous avons besoin pour un ensemble en Java."
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr "Vous pouvez maintenant tester et ajouter des éléments à cette collection, juste comme nous l'avons fait avant en liant des personnes et des événements. C'est le même code en Java."
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr "Cette fois ci, nous n'avons pas utilisé une requête de chargement agressif (<emphasis>fetch</emphasis>) pour initialiser la collection. Par conséquent, l'invocation du getter déclenchera un select supplémentaire pour l'initialiser. Traquez les logs SQL et tentez d'optimiser ce cas avec un chargement aggressif."
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr "Associations bidirectionnelles"
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr "Ensuite nous allons mapper une association bidirectionnelle - faire fonctionner l'association entre une personne et un événement à partir des deux côtés en Java. Bien sûr, le schéma de la base de données ne change pas, nous avons toujours une pluralité many-to-many. Une base de données relationnelle est plus flexible qu'un langage de programmation réseau, donc elle n'a pas besoin de direction de navigation - les données peuvent être vues et récupérées de toutes les manières possibles."
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr "D'abord, ajouter une collection de participants à la classe <literal>Event</literal> :"
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr "Maintenant mapper ce côté de l'association aussi, dans <literal>Event.hbm.xml</literal>."
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr "Comme vous le voyez, ce sont des mappings de <literal>set</literal>s normaux dans les deux documents de mapping. Notez que les noms de colonne dans <literal>key</literal> et <literal>many-to-many</literal> sont inversés dans les 2 documents de mapping. L'ajout le plus important ici est l'attribut <literal>inverse=\"true\"</literal> dans l'élément <literal>set</literal> du mapping de la collection des <literal>Event</literal>s."
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr "Ce que signifie qu'Hibernate devrait prendre l'autre côté - la classe <literal>Person</literal> - s'il a besoin de renseigner des informations à propos du lien entre les deux. Ce sera beaucoup plus facile à comprendre une fois que vous verrez comment le lien bidirectionnel entre les deux entités est créé."
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr "Travailler avec des liens bidirectionnels"
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr "Premièrement, gardez à l'esprit qu'Hibernate n'affecte pas la sémantique normale de Java. Comment avons-nous créé un lien entre une <literal>Person</literal> et un <literal>Event</literal> dans l'exemple unidirectionnel ? Nous avons ajouté une instance de <literal>Event</literal> à la collection des références d'événement d'une instance de <literal>Person</literal>. Donc, évidemment, si vous voulons rendre ce lien bidirectionnel, nous devons faire la même chose de l'autre côté - ajouter une référence de <literal>Person</literal> à la collection d'un <literal>Event</literal>. Cette \"configuration du lien des deux côtés\" est absolument nécessaire et vous ne devriez jamais oublier de le faire."
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr "Beaucoup de développeurs programment de manière défensive et créent des méthodes de gestion de lien pour affecter correctement les deux côtés, par exemple dans <literal>Person</literal> :"
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr "Notez que les méthodes get et set pour la collection sont maintenant protégées - ceci permet à des classes du même paquet et aux sous-classes d'accéder encore aux méthodes, mais empêche n'importe qui d'autre de mettre le désordre directement dans les collections (enfin, presque). Vous devriez probablement faire de même avec la collection de l'autre côté."
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr "Et à propos de l'attribut de mapping <literal>inverse</literal> ? Pour vous, et pour Java, un lien bidirectionnel est simplement une manière de configurer correctement les références des deux côtés. Hibernate n'a cependant pas assez d'informations pour ordonner correctement les expressions SQL <literal>INSERT</literal> et <literal>UPDATE</literal> (pour éviter les violations de contrainte), et a besoin d'aide pour gérer proprement les associations bidirectionnelles. Rendre <literal>inverse</literal> un côté d'une assocation dit à Hibernate de l'ignorer essentiellement, pour le considérer comme un <emphasis>miroir</emphasis> de l'autre côté. C'est tout ce qui est nécessaire à Hibernate pour découvrir tout des problèmes de transformation d'un modèle de navigation directionnelle vers un schéma SQL de base de données. Les règles dont vous devez vous souvenir sont : toutes les associations bidirectionnelles ont besoin d'un côté marqué <literal>in!
verse</literal>. Dans une association un-vers-plusieurs vous pouvez choisir n'importe quel côté, il n'y a pas de différence."
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr "Part 3 - L'application web EventManager"
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr "Une application web Hibernate utilise la <literal>Session</literal> et <literal>Transaction</literal> comme une application standalone. Cependant, quelques patterns sont utiles. Nous allons coder une <literal>EventManagerServlet</literal>. Cette servlet peut lister tous les évènements stockés dans la base de données, et fournir une formulaire HTML pour saisir d'autres évènements."
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr "Ecrire la servlet de base"
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr "Créons une nouvelle classe dans notre répertoire source, dans le package <literal>events</literal>:"
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " private final SimpleDateFormat dateFormatter =\n"
+ " new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr "Le <literal>dateFormatter</literal> est un outil que nous utiliserons plus tard pour convertir les objets <literal>Date</literal> depuis et vers des chaines de caractères. Il est propice de n'avoir qu'un formatter comme membre de la servlet."
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr "La servlet n'accepte que les requêtes HTTP <literal>GET</literal>, la méthode à implémenter est donc <literal>doGet()</literal>:"
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr "La pattern que nous utilisons ici est appelé <emphasis>session-per-request</emphasis>. Lorsqu'une requête touche la servlet, une nouvelle <literal>Session</literal> hibernate est ouverte à l'invocationde <literal>getCurrentSession()</literal> sur la <literal>SessionFactory</literal>. Ensuite, une transaction avec la base de données est démarrée— tous les accès à la base de données interviennent au sein de la transactiton, peu importe que les données soient lues ou écrites (nous n'utilisons pas le mode auto-commit dans les applications)."
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr "Ensuite, les actions possibles de la requêtes sont exécutées et la réponse HTML est rendue. Nous en parlerons plus tard."
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "Enfin, l'unité de travail s'achève lorsque l'exécution et le rendu sont achevés. Si un problème survient lors de ces deux phases, une exception est soulevée et la transaction avec la base de données subit un rollback. Voila pour le pattern <literal>session-per-request</literal>. Au lieu d'un code de démarcation de transaction au sein de chaque servlet, vous pouvez écrire un filtre de servlet. Voir le site Hibernate et le Wiki pour plus d'information sur ce pattern, appelé <emphasis>Open Session in View</emphasis>— vous en aurez besoin dès que vous utiliserez des JSPs et non plus des servlets pour le rendu de vos vues."
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr "Procéder et rendre"
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr "Implémentons l'exécution de la requête et le rendu de la page."
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr "Ce style de code avec un mix de Java et d'HTML ne serait pas scalable dans une application plus complexe—gardez à l'esprit que nous ne faisons qu'illustrer les concepts basiques d'Hibernate dans ce tutoriel. Ce code affiche une en tête et un pied de page HTML. Dans cette page, sont affichés un formulaire pour la saisie d'évènements ainsi qu'une liste de tous les évènements de la base de données. La première méthode est triviale est ne fait que sortir de l'HTML:"
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr "La méthode <literal>listEvents()</literal> utilise la <literal>Session</literal> Hibernate liée au thread courant pour exécuter la requête:"
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr ""
+ "<![CDATA[private void listEvents(PrintWriter out) {\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr "FEnfin, l'action <literal>store</literal> renvoie à la méthode <literal>createAndStoreEvent()</literal>, qui utilise aussi la <literal>Session</literal> du thread courant:"
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr "La servlet est faite. Une requête à la servlet sera exécutée par une seule <literal>Session</literal> et <literal>Transaction</literal>. Comme pour une application standalone, Hibernate peut automatiquement lier ces objets au thread courant d'exécution. Cela vous laisse la liberté de séparer votre code en couches et d'accéder à la <literal>SessionFactory</literal> par le moyen que vous voulez. Généralement, vous utiliserez des conceptions plus sophistiquées et déplacerez le code d'accès aux données dans une couche DAO. Voir le wiki Hibernate pour plus d'exemples."
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr "Déployer et tester"
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr "Pour déployer cette application, vous devez créer une archive Web, un War. Ajoutez la cible Ant suivante dans votre <literal>build.xml</literal>:"
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"servlet.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr "Cette cible créé un fichier nommé <literal>hibernate-tutorial.war</literal> dans le répertoire de votre projet. Elle package les bibliothèques et le descripteur <literal>web.xml</literal> qui est attendu dans le répertoire racine de votre projet:"
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr "Avant de compiler et déployer l'application web, notez qu'une bibliothèque supplémentaire est requise: <literal>servlet.jar</literal>. C'est le kit de développement de Servlet Java, si vous ne disposez pas de cette bibliothèque, prenez la sur le <ulink url=\"http://java.sun.com/products/servlet/archive.html\">site de Sun</ulink> et copiez la dans votre répertoire des bibliothèques. Cependant, elle ne sera utilisée uniquement pour la compilation et sera exclue du paackage WAR."
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr "Pour construire et déployer, appelez <literal>ant war</literal> dans votre projet et copier le fichier <literal>hibernate-tutorial.war</literal> dans le répertoire <literal>webapp</literal> de tomcat Si vous n'avez pas installé Tomcat, téléchargez le et suivez la notice d'installation. Vous n'avez pas à modifier la configuration Tomcat pour déployer cette application."
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr "Une fois l'application déployée et Tomcat lancé, accédez à l'application via <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Assurez vous de consulter les traces tomcat pour observer l'initialisation d'Hibernate à la première requête touchant votre servlet (l'initialisation statique dans <literal>HibernateUtil</literal> est invoquée) et pour vérifier qu'aucune exception ne survienne."
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr "Résumé"
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr "Ce didacticiel a couvert les bases de l'écriture d'une simple application Hibernate ainsi qu'une petite application web."
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr "Si vous êtes déjà confiants avec Hibernate, continuez à parcourir les sujets que vous trouvez intéressants à travers la table des matières de la documentation de référence - les plus demandés sont le traitement transactionnel (<xref linkend=\"transactions\"/>), la performance des récupérations d'information (<xref linkend=\"performance\"/>), ou l'utilisation de l'API (<xref linkend=\"objectstate\"/>) et les fonctionnalités des requêtes (<xref linkend=\"objectstate-querying\"/>)."
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr "N'oubliez pas de vérifier le site web d'Hibernate pour d'autres didacticiels (plus spécialisés)."
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr ""
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,420 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr "Mapping XML"
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr "Notez que cette fonctionnalité est expérimentale dans Hibernate 3.0 et est en développement extrêmement actif."
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr "Travailler avec des données XML"
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr "Hibernate vous laisse travailler avec des données XML persistantes de la même manière que vous travaillez avec des POJOs persistants. Un arbre XML peut être vu comme une autre manière de représenter les données relationnelles au niveau objet, à la place des POJOs."
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr "Hibernate supporte dom4j en tant qu'API pour la manipulation des arbres XML. Vous pouvez écrire des requêtes qui récupèrent des arbres dom4j à partie de la base de données, et avoir toutes les modifications que vous faites sur l'arbre automatiquement synchronisées dans la base de données. Vous pouvez même prendre un document XML, l'analyser en utilisant dom4j, et l'écrire dans la base de données via les opérations basiques d'Hibernate : <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merge() n'est pas encore supporté)."
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr "Cette fonctionnalité a plusieurs applications dont l'import/export de données, l'externalisation d'entités via JMS ou SOAP et les rapports XSLT."
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr "Un simple mapping peut être utilisé pour simultanément mapper les propriétés d'une classe et les noeuds d'un document XML vers la base de données, ou, si il n'y a pas de classe à mapper, il peut être utilisé juste pour mapper le XML."
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr "Spécifier le mapping XML et le mapping d'une classe ensemble"
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr "Voici un exemple de mapping d'un POJO et du XML simultanément :"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Account\"\n"
+ " table=\"ACCOUNTS\"\n"
+ " node=\"account\">\n"
+ "\n"
+ " <id name=\"accountId\"\n"
+ " column=\"ACCOUNT_ID\"\n"
+ " node=\"@id\"/>\n"
+ "\n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"CUSTOMER_ID\"\n"
+ " node=\"customer/@id\"\n"
+ " embed-xml=\"false\"/>\n"
+ "\n"
+ " <property name=\"balance\"\n"
+ " column=\"BALANCE\"\n"
+ " node=\"balance\"/>\n"
+ "\n"
+ " ...\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr "Spécifier seulement un mapping XML"
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr "Voici un exemple dans lequel il n'y a pas de class POJO :"
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class entity-name=\"Account\"\n"
+ " table=\"ACCOUNTS\"\n"
+ " node=\"account\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " column=\"ACCOUNT_ID\"\n"
+ " node=\"@id\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"customerId\"\n"
+ " column=\"CUSTOMER_ID\"\n"
+ " node=\"customer/@id\"\n"
+ " embed-xml=\"false\"\n"
+ " entity-name=\"Customer\"/>\n"
+ "\n"
+ " <property name=\"balance\"\n"
+ " column=\"BALANCE\"\n"
+ " node=\"balance\"\n"
+ " type=\"big_decimal\"/>\n"
+ "\n"
+ " ...\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr "Ce mapping vous permet d'accéder aux données comme un arbre dom4j, ou comme un graphe de paire nom de propriété/valeur (<literal>Map</literal>s java). Les noms des propriétés sont des constructions purement logiques qui peuvent être référées des dans requêtes HQL."
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr "Métadonnées du mapping XML"
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr "Plusieurs éléments du mapping Hibernate acceptent l'attribut <literal>node</literal>. Ceci vous permet de spécifier le nom d'un attribut XML ou d'un élément qui contient la propriété ou les données de l'entité. Le format de l'attribut <literal>node</literal> doit être un des suivants :"
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr "<literal>\"element-name\"</literal> - mappe vers l'élément XML nommé"
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr "<literal>\"@attribute-name\"</literal> - mappe vers l'attribut XML nommé"
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr "<literal>\".\"</literal> - mappe vers le parent de l'élément"
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr "<literal>\"element-name/@attribute-name\"</literal> - mappe vers l'élément nommé de l'attribut nommé"
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr "Pour des collections et de simples associations valuées, il y a un attribut <literal>embed-xml</literal> supplémentaire. Si <literal>embed-xml=\"true\"</literal>, qui est la valeur par défaut, l'arbre XML pour l'entité associée (ou la collection des types de valeurs) sera embarquée directement dans l'arbre XML pour l'entité qui possède l'association. Sinon, si <literal>embed-xml=\"false\"</literal>, alors seule la valeur de l'identifiant référencé apparaîtra dans le XML pour de simples associations de points, et les collections n'appraîtront simplement pas."
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr "Vous devriez faire attention à ne pas laisser <literal>embed-xml=\"true\"</literal> pour trop d'associations, puisque XML ne traite pas bien les liens circurlaires."
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\"\n"
+ " table=\"CUSTOMER\"\n"
+ " node=\"customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " column=\"CUST_ID\"\n"
+ " node=\"@id\"/>\n"
+ "\n"
+ " <map name=\"accounts\"\n"
+ " node=\".\"\n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\"\n"
+ " node=\"@short-desc\"\n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\"\n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ "\n"
+ " <component name=\"name\"\n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\"\n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\"\n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\"\n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ "\n"
+ " ...\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr "dans ce cas, nous avons décidé d'embarquer la collection d'identifiants de compte, mais pas les données actuelles du compte. La requête HQL suivante :"
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr "devrait retourner l'ensemble de données suivant :"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr "Si vous positionnez <literal>embed-xml=\"true\"</literal> sur le mapping <literal><one-to-many></literal>, les données pourraient ressembler plus à ça :"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr "Manipuler des données XML"
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr "Relisons et mettons à jour des documents XML dans l'application. Nous faisons ça en obtenant une session dom4j :"
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Document doc = ....;\n"
+ "\n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.getRootElement().add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr "Il est extrêmement utile de combiner cette fonctionnalité avec l'opération <literal>replicate()</literal> d'Hibernate pour implémenter des imports/exports de données XML."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/fr-FR/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/fr-FR/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/fr-FR/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - Relational Persistence for Idiomatic Java"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "Hibernate Reference Documentation"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr ""
+
+#: index.docbook:24
+msgid "Overview"
+msgstr ""
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr ""
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr ""
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 ""
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr ""
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr ""
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr ""
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr ""
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr ""
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr ""
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr ""
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr ""
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr ""
+
+#: index.docbook:119
+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 ""
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr ""
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 ""
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr ""
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr ""
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr ""
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr ""
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr ""
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr ""
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr ""
+
+#: index.docbook:188
+msgid "transient"
+msgstr ""
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr ""
+
+#: index.docbook:198
+msgid "persistent"
+msgstr ""
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr ""
+
+#: index.docbook:212
+msgid "detached"
+msgstr ""
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr ""
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr ""
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr ""
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr ""
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr ""
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr ""
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr ""
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr ""
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr ""
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr ""
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 ""
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr ""
+
+#: index.docbook:307
+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 ""
+
+#: index.docbook:314
+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 ""
+
+#: index.docbook:324
+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 ""
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr ""
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr ""
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1269 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr "関連マッピング"
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr "イントãƒãƒ€ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr "関連マッピングã¯ã—ã°ã—ã°ç†è§£ãŒæœ€ã‚‚難ã—ã„ã‚‚ã®ã«ãªã‚Šã¾ã™ã€‚ ã“ã®ç« ã§ã¯ã€åŸºæœ¬çš„ãªä¸€ã¤ä¸€ã¤ã®ã‚±ãƒ¼ã‚¹ã«ã¤ã„ã¦è¿°ã¹ã¾ã™ã€‚ å˜æ–¹å‘ã®ãƒžãƒƒãƒ”ングã‹ã‚‰å§‹ã‚ã€ãã‚Œã‹ã‚‰åŒæ–¹å‘ã®ã‚±ãƒ¼ã‚¹ã«ã¤ã„ã¦è€ƒãˆã¦ã„ãã¾ã™ã€‚ 例ã¨ã—ã¦ã€<literal>Person</literal> 㨠<literal>Address</literal> を用ã„ã¾ã™ã€‚"
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr "関連ã¯ã€çµåˆãƒ†ãƒ¼ãƒ–ルを入れるã‹ã‹ã©ã†ã‹ã¨ã€ 多é‡åº¦ã«ã‚ˆã£ã¦åˆ†é¡žã™ã‚‹ã“ã¨ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr "ã™ã¹ã¦ã®ä¾‹ã§not nullã®å¤–部ã‚ーを使用ã—ã¾ã™ã€‚ ã“ã‚Œã¯Hibernateã®è¦ä»¶ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 not null制約を外ã—ãŸã¨ã—ã¦ã‚‚ã€ãƒžãƒƒãƒ”ングã¯å•é¡Œãªã動作ã—ã¾ã™ã€‚"
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr "å˜æ–¹å‘関連"
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr "<title>多対一</title>"
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr "<emphasis>å˜æ–¹å‘多対一関連</emphasis> ã¯å˜æ–¹å‘関連ã®ä¸ã§æœ€ã‚‚一般的ãªã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr "<title>一対一</title>"
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr "<emphasis>外部ã‚ーã®å˜æ–¹å‘一対一関連</emphasis> ã¯ã»ã¨ã‚“ã©åŒã˜ã‚‚ã®ã§ã™ã€‚ 唯一é•ã†ã®ã¯ã€ã‚«ãƒ©ãƒ ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªåˆ¶ç´„ã§ã™ã€‚"
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " unique=\"true\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr "<emphasis>主ã‚ーã®å˜æ–¹å‘一対一関連</emphasis> ã¯é€šå¸¸ã€ç‰¹åˆ¥ãªIDジェãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã„ã¾ã™ã€‚ （ã“ã®ä¾‹ã§ã¯é–¢é€£ã®æ–¹å‘ãŒé€†ã«ãªã£ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„）"
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"foreign\">
+\n"
+ " <param name=\"property\">person</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table Address ( personId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr "<title>一対多</title>"
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr "<emphasis>外部ã‚ーã®å˜æ–¹å‘一対多関連</emphasis> ã¯ã¨ã¦ã‚‚特殊ãªã‚±ãƒ¼ã‚¹ã§ã€ ã‚ã¾ã‚ŠæŽ¨å¥¨ã•ã‚Œã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"addresses\">
+\n"
+ " <key column=\"personId\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ " <one-to-many class=\"Address\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )
+\n"
+ " ]]>"
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr "ã“ã®ã‚ˆã†ãªé–¢é€£ã®ãŸã‚ã«çµåˆãƒ†ãƒ¼ãƒ–ルを使ã†ã“ã¨ã‚’ãŠè–¦ã‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr "çµåˆãƒ†ãƒ¼ãƒ–ルを使ã£ãŸå˜æ–¹å‘関連"
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr "<emphasis>çµåˆãƒ†ãƒ¼ãƒ–ルを使ã£ãŸå˜æ–¹å‘一対多関連</emphasis> ã¯ã‚ˆã‚Šå¥½ã¾ã—ã„ã§ã™ã€‚ <literal>unique=\"true\"</literal> ã®æŒ‡å®šã«ã‚ˆã‚Šã€å¤šé‡åº¦ãŒå¤šå¯¾å¤šã‹ã‚‰ä¸€å¯¾å¤š ã«å¤‰ã‚ã£ãŸã“ã¨ã«æ³¨æ„ã—ã¦ä¸‹ã•ã„。"
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">
+\n"
+ " <key column=\"personId\"/>
+\n"
+ " <many-to-many column=\"addressId\"
+\n"
+ " unique=\"true\"
+\n"
+ " class=\"Address\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr "<emphasis>çµåˆãƒ†ãƒ¼ãƒ–ルã®å˜æ–¹å‘多対一関連</emphasis> 㯠関連ãŒä»»æ„ã§ã‚ã‚‹ã¨ãã«éžå¸¸ã«ä¸€èˆ¬çš„ãªã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <join table=\"PersonAddress\"
+\n"
+ " optional=\"true\">
+\n"
+ " <key column=\"personId\" unique=\"true\"/>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ " </join>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "<emphasis>çµåˆãƒ†ãƒ¼ãƒ–ルã®å˜æ–¹å‘一対一関連</emphasis> ã¯ã€æœ¬å½“ã«ç‰¹æ®Šã§ã™ãŒ ä¸å¯èƒ½ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <join table=\"PersonAddress\"
+\n"
+ " optional=\"true\">
+\n"
+ " <key column=\"personId\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " </join>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr "<title>多対多</title>"
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr "最後ã«ã€<emphasis>å˜æ–¹å‘多対多関連</emphasis> を示ã—ã¾ã™ã€‚"
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">
+\n"
+ " <key column=\"personId\"/>
+\n"
+ " <many-to-many column=\"addressId\"
+\n"
+ " class=\"Address\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "</class>]]>"
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr "åŒæ–¹å‘関連"
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr "一対多/多対一"
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr "<emphasis>åŒæ–¹å‘多対一関連</emphasis> ã¯æœ€ã‚‚一般的ãªé–¢é€£ã§ã™ã€‚ （標準的ãªè¦ªå関係ã§ã™ï¼‰"
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"people\" inverse=\"true\">
+\n"
+ " <key column=\"addressId\"/>
+\n"
+ " <one-to-many class=\"Person\"/>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr "<literal>List</literal> （ã¾ãŸã¯ä»–ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼‰ã‚’使ã†ãªã‚‰ã€ 外部ã‚ー㮠<literal>key</literal> カラムを <literal>not null</literal> ã«è¨å®šã—〠コレクションå´ãŒå„è¦ç´ ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’メンテナンスã™ã‚‹ã‚ˆã†ã«ã€ 関連を扱ã†å¿…è¦ãŒã‚ã‚Šã¾ã™ （<literal>update=\"false\"</literal> ã‹ã¤ <literal>insert=\"false\"</literal> ã¨è¨å®šã—ã¦ã€å対å´ã‚’仮想的ã«inverseã«ã—ã¾ã™ï¼‰ï¼š"
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\"/>
+\n"
+ " ...
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"
+\n"
+ " insert=\"false\"
+\n"
+ " update=\"false\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\"/>
+\n"
+ " ...
+\n"
+ " <list name=\"people\">
+\n"
+ " <key column=\"addressId\" not-null=\"true\"/>
+\n"
+ " <list-index column=\"peopleIdx\"/>
+\n"
+ " <one-to-many class=\"Person\"/>
+\n"
+ " </list>
+\n"
+ "</class>]]>"
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr "ã‚‚ã—外部ã‚ーカラム㌠<literal>NOT NULL</literal> ã§ã‚ã‚‹ãªã‚‰ã°ã€ コレクションマッピング㮠<literal><key></literal> è¦ç´ ã‚’ <literal>not-null=\"true\"</literal> ã«ã™ã‚‹ã“ã¨ã¯é‡è¦ã§ã™ã€‚ 入れåã«ãªã£ãŸ <literal><column></literal> è¦ç´ ã ã‘ã§ã¯ãªã〠<literal><key></literal> è¦ç´ ã‚‚ <literal>not-null=\"true\"</literal> ã¨å®šç¾©ã—ãªã„よã†ã«ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr "<emphasis>外部ã‚ーã®åŒæ–¹å‘一対一関連</emphasis> ã¯éžå¸¸ã«ä¸€èˆ¬çš„ã§ã™ã€‚"
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " unique=\"true\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <one-to-one name=\"person\"
+\n"
+ " property-ref=\"address\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr "<emphasis>主ã‚ーã®åŒæ–¹å‘一対一関連</emphasis> ã¯ç‰¹æ®ŠãªIDジェãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã„ã¾ã™ã€‚"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <one-to-one name=\"address\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"foreign\">
+\n"
+ " <param name=\"property\">person</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " <one-to-one name=\"person\"
+\n"
+ " constrained=\"true\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr "çµåˆãƒ†ãƒ¼ãƒ–ルを使ã£ãŸåŒæ–¹å‘関連"
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr "<emphasis>çµåˆãƒ†ãƒ¼ãƒ–ルã®åŒæ–¹å‘一対多関連</emphasis> ã§ã™ã€‚ <literal>inverse=\"true\"</literal> ãŒé–¢é€£ç«¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€çµåˆã®ã„ãšã‚Œã‹ã« è¨å®šã§ãã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"addresses\"
+\n"
+ " table=\"PersonAddress\">
+\n"
+ " <key column=\"personId\"/>
+\n"
+ " <many-to-many column=\"addressId\"
+\n"
+ " unique=\"true\"
+\n"
+ " class=\"Address\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <join table=\"PersonAddress\"
+\n"
+ " inverse=\"true\"
+\n"
+ " optional=\"true\">
+\n"
+ " <key column=\"addressId\"/>
+\n"
+ " <many-to-one name=\"person\"
+\n"
+ " column=\"personId\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ " </join>
+\n"
+ "</class>]]>"
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "create table Person ( personId bigint not null primary key )
+\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )
+\n"
+ "create table Address ( addressId bigint not null primary key )
+\n"
+ " ]]>"
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "<emphasis>çµåˆãƒ†ãƒ¼ãƒ–ルã®åŒæ–¹å‘一対一関連</emphasis> ã¯éžå¸¸ã«ç‰¹æ®Šã§ã™ãŒã€å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <join table=\"PersonAddress\"
+\n"
+ " optional=\"true\">
+\n"
+ " <key column=\"personId\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"addressId\"
+\n"
+ " not-null=\"true\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " </join>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <join table=\"PersonAddress\"
+\n"
+ " optional=\"true\"
+\n"
+ " inverse=\"true\">
+\n"
+ " <key column=\"addressId\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " <many-to-one name=\"address\"
+\n"
+ " column=\"personId\"
+\n"
+ " not-null=\"true\"
+\n"
+ " unique=\"true\"/>
+\n"
+ " </join>
+\n"
+ "</class>]]>"
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr "最後ã«ã€<emphasis>åŒæ–¹å‘多対多関連</emphasis> を示ã—ã¾ã™ã€‚"
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"id\" column=\"personId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">
+\n"
+ " <key column=\"personId\"/>
+\n"
+ " <many-to-many column=\"addressId\"
+\n"
+ " class=\"Address\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ " <id name=\"id\" column=\"addressId\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">
+\n"
+ " <key column=\"addressId\"/>
+\n"
+ " <many-to-many column=\"personId\"
+\n"
+ " class=\"Person\"/>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr "より複雑ãªé–¢é€£ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr "より複雑ãªé–¢é€£çµåˆã¯ <emphasis>極ã‚ã¦</emphasis> 稀ã§ã™ã€‚ マッピングドã‚ュメントã«SQL文を埋ã‚込むã“ã¨ã§ã€ ã•ã‚‰ã«è¤‡é›‘ãªçŠ¶æ³ã‚’扱ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ 例ãˆã°ã€<literal>accountNumber</literal>, <literal>effectiveEndDate</literal>, <literal>effectiveStartDate</literal> カラムをæŒã¤account（å£åº§ï¼‰æƒ…å ±ã®å±¥æ´ã‚’扱ã†ãƒ†ãƒ¼ãƒ–ルã¯ã€ 以下ã®ã‚ˆã†ã«ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚"
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr ""
+ "<![CDATA[<properties name=\"currentAccountKey\">
+\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>
+\n"
+ " <property name=\"currentAccount\" type=\"boolean\">
+\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>
+\n"
+ " </property>
+\n"
+ "</properties>
+\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>
+\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr "ãã—ã¦ã€é–¢é€£ã‚’ <emphasis>ç¾æ™‚点ã®</emphasis> インスタンス （<literal>effectiveEndDate</literal> ãŒnullã§ã‚ã‚‹ã‚‚ã®ï¼‰ã«ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚ 以下ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ï¼š"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\"
+\n"
+ " property-ref=\"currentAccountKey\"
+\n"
+ " class=\"AccountInfo\">
+\n"
+ " <column name=\"accountNumber\"/>
+\n"
+ " <formula>'1'</formula>
+\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr "ã•ã‚‰ã«è¤‡é›‘ãªä¾‹ã§ã¯ã€<literal>Employee（従æ¥å“¡ï¼‰</literal> 㨠<literal>Organization（組織）</literal> é–“ã®é–¢é€£ãŒ <literal>Employment（雇用）</literal> テーブルã§ä¿æŒã•ã‚Œã‚‹å ´åˆã‚’想åƒã—ã¦ãã ã•ã„。 ã“ã®ãƒ†ãƒ¼ãƒ–ルã«ã¯é›‡ç”¨ãƒ‡ãƒ¼ã‚¿ã®å±¥æ´ãŒã™ã¹ã¦å«ã¾ã‚Œã¾ã™ã€‚ ã™ã‚‹ã¨å¾“æ¥å“¡ã® <emphasis>最も最近ã®</emphasis> 雇用者を表ã™é–¢é€£ （最も最近㮠<literal>startDate</literal> ã‚’æŒã¤ã‚‚ã®ï¼‰ã¯ã€ã“ã®ã‚ˆã†ã«ãƒžãƒƒãƒ”ングã§ãã¾ã™ï¼š"
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr ""
+ "<![CDATA[<join>
+\n"
+ " <key column=\"employeeId\"/>
+\n"
+ " <subselect>
+\n"
+ " select employeeId, orgId
+\n"
+ " from Employments
+\n"
+ " group by orgId
+\n"
+ " having startDate = max(startDate)
+\n"
+ " </subselect>
+\n"
+ " <many-to-one name=\"mostRecentEmployer\"
+\n"
+ " class=\"Organization\"
+\n"
+ " column=\"orgId\"/>
+\n"
+ "</join>]]>"
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr "ã“ã®æ©Ÿèƒ½ã¯éžå¸¸ã«å¼·åŠ›ã§ã™ã€‚ ã—ã‹ã—ã“ã®ã‚ˆã†ãªå ´åˆã€æ™®é€šã¯HQLã‚„criteriaクエリを使ã†æ–¹ãŒã‚ˆã‚Šå®Ÿè·µçš„ã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,3698 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr "基本的ãªO/Rマッピング"
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr "マッピング定義"
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr "オブジェクト/リレーショナルマッピングã¯é€šå¸¸XMLドã‚ュメントã§å®šç¾©ã—ã¾ã™ã€‚ マッピングドã‚ュメントã¯ã€èªã¿ã‚„ã™ã手作æ¥ã§ç·¨é›†ã—ã‚„ã™ã„よã†ã«ãƒ‡ã‚¶ã‚¤ãƒ³ã•ã‚Œã¦ã„ã¾ã™ã€‚ マッピング言語ã¯Javaä¸å¿ƒã€ã¤ã¾ã‚Šãƒ†ãƒ¼ãƒ–ル定義ã§ã¯ãªã永続クラスã®å®šç¾©ã«åŸºã¥ã„ã¦æ§‹ç¯‰ã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr "多ãã®Hibernateユーザã¯XMLマッピングã®è¨˜è¿°ã‚’手作æ¥ã§è¡Œã„ã¾ã™ãŒã€ XDoclet, Middlegen, AndroMDAã¨ã„ã†ã‚ˆã†ãªãƒžãƒƒãƒ”ングドã‚ュメントを生æˆã™ã‚‹ãƒ„ール㌠ã„ãã¤ã‹å˜åœ¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr "サンプルã®ãƒžãƒƒãƒ”ングã‹ã‚‰å§‹ã‚ã¾ã—ょã†ï¼š"
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>
+\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">
+\n"
+ "
+\n"
+ "<hibernate-mapping package=\"eg\">
+\n"
+ "
+\n"
+ " <class name=\"Cat\"
+\n"
+ " table=\"cats\"
+\n"
+ " discriminator-value=\"C\">
+\n"
+ "
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <discriminator column=\"subclass\"
+\n"
+ " type=\"character\"/>
+\n"
+ "
+\n"
+ " <property name=\"weight\"/>
+\n"
+ "
+\n"
+ " <property name=\"birthdate\"
+\n"
+ " type=\"date\"
+\n"
+ " not-null=\"true\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <property name=\"color\"
+\n"
+ " type=\"eg.types.ColorUserType\"
+\n"
+ " not-null=\"true\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <property name=\"sex\"
+\n"
+ " not-null=\"true\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <property name=\"litterId\"
+\n"
+ " column=\"litterId\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"mother\"
+\n"
+ " column=\"mother_id\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <set name=\"kittens\"
+\n"
+ " inverse=\"true\"
+\n"
+ " order-by=\"litter_id\">
+\n"
+ " <key column=\"mother_id\"/>
+\n"
+ " <one-to-many class=\"Cat\"/>
+\n"
+ " </set>
+\n"
+ "
+\n"
+ " <subclass name=\"DomesticCat\"
+\n"
+ " discriminator-value=\"D\">
+\n"
+ "
+\n"
+ " <property name=\"name\"
+\n"
+ " type=\"string\"/>
+\n"
+ "
+\n"
+ " </subclass>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Dog\">
+\n"
+ " <!-- ã“ã“ã«Dog用ã®ãƒžãƒƒãƒ”ング書ãã¾ã™ -->
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr "マッピングドã‚ュメントã®å†…容を説明ã—ã¾ã™ã€‚。 ãŸã ã—ã€ã“ã“ã§ã¯HibernateãŒå®Ÿè¡Œæ™‚ã«ä½¿ã†ãƒ‰ã‚ュメントè¦ç´ ã¨å±žæ€§ã«ã¤ã„ã¦ã®ã¿èª¬æ˜Žã—ã¾ã™ã€‚ マッピングドã‚ュメントã¯ã€ã„ãã¤ã‹ã®ã‚ªãƒ—ション属性ã¨è¦ç´ ã‚’å«ã‚“ã§ã„ã¾ã™ï¼ˆä¾‹ãˆã° <literal>not-null</literal> 属性）。 ãれらã¯ã‚¹ã‚ーマエクスãƒãƒ¼ãƒˆãƒ„ールãŒå‡ºåŠ›ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã«å½±éŸ¿ã‚’与ãˆã‚‹ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr "Doctype"
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr "XMLマッピングã§ã¯ã€ãŠè¦‹ã›ã—ãŸã‚ˆã†ãªãƒ‰ã‚ュメント型を必ãšå®šç¾©ã™ã¹ãã§ã™ã€‚ 実際ã®DTDã¯ã€ä¸Šè¨˜ã®URLã® <literal>hibernate-x.x.x/src/org/hibernate</literal> ディレクトリ〠ã¾ãŸã¯ <literal>hibernate.jar</literal> 内ã«ã‚ã‚Šã¾ã™ã€‚ Hibernateã¯å¸¸ã«ã€ãã®ã‚¯ãƒ©ã‚¹ãƒ‘ス内ã§DTDを探ã—始ã‚ã¾ã™ã€‚ インターãƒãƒƒãƒˆã«ã‚ã‚‹DTDファイルを探ãã†ã¨ã—ãŸãªã‚‰ã€ クラスパスã®å†…容を見ã¦ã€DTD宣言を確èªã—ã¦ãã ã•ã„。"
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr "エンティティ・リゾルãƒ"
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr "å‰è¿°ã—ãŸã‚ˆã†ã«ã€Hibernateã¯ã¾ãšã‚¯ãƒ©ã‚¹ãƒ‘ス内ã§DTDを解決ã—よã†ã¨ã—ã¾ã™ã€‚ <literal>org.xml.sax.EntityResolver</literal> ã®ã‚«ã‚¹ã‚¿ãƒ 実装を XMLファイルをèªã¿è¾¼ã‚€ãŸã‚ã®SAXReaderã«ç™»éŒ²ã™ã‚‹ã“ã¨ã«ã‚ˆã£ã¦ã€DTDを解決ã—ã¾ã™ã€‚ ã“ã®ã‚«ã‚¹ã‚¿ãƒ ã® <literal>EntityResolver</literal> ã¯2ã¤ã®ç•°ãªã‚‹ã‚·ã‚¹ãƒ†ãƒ IDåå‰ç©ºé–“ã‚’èªè˜ã—ã¾ã™ã€‚"
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr "<literal>Hibernateåå‰ç©ºé–“</literal> ã¯ã€ãƒªã‚¾ãƒ«ãƒãŒ <literal>http://hibernate.sourceforge.net/</literal> ã§å§‹ã¾ã‚‹ã‚·ã‚¹ãƒ†ãƒ IDã«åˆ°é”ã—ãŸã¨ãã«ã€ èªè˜ã•ã‚Œã¾ã™ã€‚ ãã—ã¦ãƒªã‚¾ãƒ«ãƒã¯ã€Hibernateã®ã‚¯ãƒ©ã‚¹ã‚’ãƒãƒ¼ãƒ‰ã—ãŸã‚¯ãƒ©ã‚¹ãƒãƒ¼ãƒ€ã‚’用ã„ã¦ã€ ã“れらã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’解決ã—よã†ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "<literal>ユーザåå‰ç©ºé–“</literal> ã¯ã€ãƒªã‚¾ãƒ«ãƒãŒ URLプãƒãƒˆã‚³ãƒ«ã® <literal>classpath://</literal> を使ã£ãŸã‚·ã‚¹ãƒ†ãƒ IDã«åˆ°é”ã—ãŸã¨ãã«ã€ èªè˜ã•ã‚Œã¾ã™ã€‚ãã—ã¦ãƒªã‚¾ãƒ«ãƒã¯ã€(1)カレントスレッドã®ã‚³ãƒ³ãƒ†ã‚ストクラスãƒãƒ¼ãƒ€ãƒ¼ã€ ã¾ãŸã¯(2)Hibernateã®ã‚¯ãƒ©ã‚¹ã‚’ãƒãƒ¼ãƒ‰ã—ãŸã‚¯ãƒ©ã‚¹ãƒãƒ¼ãƒ€ã‚’使ã£ã¦ã€ ã“れらã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’解決ã—よã†ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr "下記ã¯ã€ãƒ¦ãƒ¼ã‚¶åå‰ç©ºé–“を使ã£ãŸä¾‹ã§ã™ï¼š"
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>
+\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [
+\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">
+\n"
+ "]>
+\n"
+ "
+\n"
+ "<hibernate-mapping package=\"your.domain\">
+\n"
+ " <class name=\"MyEntity\">
+\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">
+\n"
+ " ...
+\n"
+ " </id>
+\n"
+ " <class>
+\n"
+ " &types;
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr "ã“ã“㧠<literal>types.xml</literal> 㯠<literal>your.domain</literal> パッケージ内ã®ãƒªã‚½ãƒ¼ã‚¹ã§ã‚り〠カスタム<xref linkend=\"mapping-types-custom\"/>typedef ã‚’å«ã‚€ã¾ã™ã€‚"
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr "hibernate-mapping"
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr "ã“ã®è¦ç´ ã«ã¯ã„ãã¤ã‹ã‚ªãƒ—ション属性ãŒã‚ã‚Šã¾ã™ã€‚<literal>schema</literal> 属性㨠<literal>catalog</literal> 属性ã¯ã€ ã“ã®ãƒžãƒƒãƒ”ングãŒå‚ç…§ã™ã‚‹ãƒ†ãƒ¼ãƒ–ルãŒã€ã“ã®å±žæ€§ã«ã‚ˆã£ã¦æŒ‡å®šã•ã‚ŒãŸã‚¹ã‚ーマã¨(ã¾ãŸã¯)ã‚«ã‚¿ãƒã‚°ã«å±žã™ã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚ ã“ã®å±žæ€§ãŒæŒ‡å®šã•ã‚Œã‚‹ã¨ã€ãƒ†ãƒ¼ãƒ–ルåã¯ä¸Žãˆã‚‰ã‚ŒãŸã‚¹ã‚ーマåã¨ã‚«ã‚¿ãƒã‚°åã§ä¿®é£¾ã•ã‚Œã¾ã™ã€‚ã“れらã®å±žæ€§ãŒæŒ‡å®šã•ã‚Œã¦ã„ãªã‘ã‚Œã°ã€ テーブルåã¯ä¿®é£¾ã•ã‚Œã¾ã›ã‚“。<literal>default-cascade</literal> 属性ã¯ã€ <literal>cascade</literal> 属性を指定ã—ã¦ã„ãªã„プãƒãƒ‘ティやコレクションã«ã€ ã©ã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã‚¹ã‚¿ã‚¤ãƒ«ã‚’割り当ã¦ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚ <literal>auto-import</literal> 属性ã¯ã€ クエリ言語内ã§ä¿®é£¾ã•ã‚Œã¦ã„ãªã„クラスåã‚’ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ä½¿ãˆã‚‹ã‚ˆã†ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping
+\n"
+ " schema=\"schemaName\"
+\n"
+ " catalog=\"catalogName\"
+\n"
+ " default-cascade=\"cascade_style\"
+\n"
+ " default-access=\"field|property|ClassName\"
+\n"
+ " default-lazy=\"true|false\"
+\n"
+ " auto-import=\"true|false\"
+\n"
+ " package=\"package.name\"
+\n"
+ " />]]>"
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr "<literal>schema</literal>（オプション）：データベーススã‚ーマã®åå‰ã€‚"
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr "<literal>catalog</literal> （オプション）：データベースカタãƒã‚°ã®åå‰ã€‚"
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr "<literal>default-cascade</literal> （オプション - デフォルト㯠<literal>none</literal>）： デフォルトã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã‚¹ã‚¿ã‚¤ãƒ«ã€‚"
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "<literal>default-access</literal> (オプション - デフォルト㯠<literal>property</literal> ）： HibernateãŒãƒ—ãƒãƒ‘ティã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹éš›ã«æŽ¡ã‚‹ã¹ã戦略。 <literal>PropertyAccessor</literal> を実装ã™ã‚‹ã“ã¨ã§ã‚«ã‚¹ã‚¿ãƒžã‚¤ã‚ºå¯èƒ½ã€‚"
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr "<literal>default-lazy</literal> (オプション - デフォルト㯠<literal>true</literal> )： <literal>lazy</literal> 属性ãŒæŒ‡å®šã•ã‚Œã¦ã„ãªã„クラスやコレクションマッピングã«å¯¾ã™ã‚‹ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã€‚"
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr "<literal>auto-import</literal> （オプション - デフォルト㯠<literal>true</literal>）： クエリ言語内ã§ã€ï¼ˆã“ã®ãƒžãƒƒãƒ”ング内ã®ã‚¯ãƒ©ã‚¹ã®ï¼‰ä¿®é£¾ã•ã‚Œã¦ã„ãªã„クラスåを使ãˆã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr "<literal>package</literal> (オプション): マッピングドã‚ュメント内ã§ä¿®é£¾ã•ã‚Œã¦ã„ãªã„クラスåã«å¯¾ã—ã¦å‰²ã‚Šå½“ã¦ã‚‹ã€ パッケージã®æŽ¥é 辞(prefix)を指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr "（修飾ã•ã‚Œã¦ã„ãªã„）åŒã˜åå‰ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ãŒ2ã¤ã‚ã‚‹ãªã‚‰ã€ <literal>auto-import=\"false\"</literal> ã‚’è¨å®šã™ã¹ãã§ã™ã€‚ 2ã¤ã®ã‚¯ãƒ©ã‚¹ã«â€ã‚¤ãƒ³ãƒãƒ¼ãƒˆã•ã‚ŒãŸâ€åŒã˜åå‰ã‚’割り当ã¦ã‚ˆã†ã¨ã™ã‚‹ã¨ã€Hibernateã¯ä¾‹å¤–を投ã’ã¾ã™ã€‚"
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "<literal>hibernate-mapping</literal> è¦ç´ ã¯ã€æœ€åˆã®ä¾‹ã§ç¤ºã—ãŸã‚ˆã†ã«ã„ãã¤ã‹ã®æ°¸ç¶š <literal><class></literal> マッピングをãƒã‚¹ãƒˆã§ãã¾ã™ã€‚ ã—ã‹ã—ã€ï¼‘ã¤ã®ãƒžãƒƒãƒ”ングファイルã§ã¯ãŸã ã²ã¨ã¤ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹(ã¾ãŸã¯ã²ã¨ã¤ã®ã‚¯ãƒ©ã‚¹éšŽå±¤)ã«ãƒžãƒƒãƒ”ングã™ã‚‹ã‚ˆã†ã«ã—〠ã•ã‚‰ã«æ°¸ç¶šã‚¹ãƒ¼ãƒ‘ークラスã®å¾Œã§æŒ‡å®šã™ã‚‹ã¹ãã§ã—ょã†(ã„ãã¤ã‹ã®ãƒ„ールã¯ã“ã®ã‚ˆã†ãªãƒžãƒƒãƒ”ングファイルを想定ã—ã¦ã„ã¾ã™)。 例ãˆã°æ¬¡ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚： <literal>Cat.hbm.xml</literal> , <literal>Dog.hbm.xml</literal> , ã¾ãŸã¯ç¶™æ‰¿ã‚’使ã†ãªã‚‰ <literal>Animal.hbm.xml</literal> 。"
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr "<title>class</title>"
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr "<literal>class</literal> è¦ç´ を使ã£ã¦ã€æ°¸ç¶šã‚¯ãƒ©ã‚¹ã‚’宣言ã§ãã¾ã™ã€‚"
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr ""
+ "<![CDATA[<class
+\n"
+ " name=\"ClassName\"
+\n"
+ " table=\"tableName\"
+\n"
+ " discriminator-value=\"discriminator_value\"
+\n"
+ " mutable=\"true|false\"
+\n"
+ " schema=\"owner\"
+\n"
+ " catalog=\"catalog\"
+\n"
+ " proxy=\"ProxyInterface\"
+\n"
+ " dynamic-update=\"true|false\"
+\n"
+ " dynamic-insert=\"true|false\"
+\n"
+ " select-before-update=\"true|false\"
+\n"
+ " polymorphism=\"implicit|explicit\"
+\n"
+ " where=\"arbitrary sql where condition\"
+\n"
+ " persister=\"PersisterClass\"
+\n"
+ " batch-size=\"N\"
+\n"
+ " optimistic-lock=\"none|version|dirty|all\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " check=\"arbitrary sql check condition\"
+\n"
+ " rowid=\"rowid\"
+\n"
+ " subselect=\"SQL expression\"
+\n"
+ " abstract=\"true|false\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " node=\"element-name\"
+\n"
+ "/>]]>"
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>name</literal> (オプション)：永続クラス（ã¾ãŸã¯ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ï¼‰ã®å®Œå…¨ä¿®é£¾Javaクラスå。 ã‚‚ã—ã“ã®å±žæ€§ã‚’指定ã—ãªã‘ã‚Œã°ã€POJOã§ã¯ãªã„エンティティã«å¯¾ã™ã‚‹ãƒžãƒƒãƒ”ングã¨ã—ã¦æ‰±ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr "<literal>table</literal> (オプション - デフォルトã¯ä¿®é£¾ã•ã‚Œã¦ã„ãªã„クラスå)：データベーステーブルã®åå‰"
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>discriminator-value</literal> (オプション - デフォルトã¯ã‚¯ãƒ©ã‚¹å)： ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªæŒ¯ã‚‹èˆžã„ã«ä½¿ã‚れる個々ã®ã‚µãƒ–クラスをè˜åˆ¥ã™ã‚‹ãŸã‚ã®å€¤ã€‚ 値㯠<literal>null</literal> ã‹ <literal>not null</literal> ã®ã„ãšã‚Œã‹ã‚’å–ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr "<literal>mutable</literal> (オプション〠デフォルト㯠<literal>true</literal> )： ãã®ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒæ›´æ–°å¯èƒ½ï¼ˆã¾ãŸã¯ä¸å¯èƒ½ï¼‰ã§ã‚ã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>schema</literal> （オプション）： ルート㮠<literal><hibernate-mapping></literal> è¦ç´ ã§æŒ‡å®šã•ã‚ŒãŸã‚¹ã‚ーマåをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>catalog</literal> （オプション）：ルート㮠<literal><hibernate-mapping></literal> è¦ç´ ã§æŒ‡å®šã•ã‚ŒãŸã‚«ã‚¿ãƒã‚°åをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr "<literal>proxy</literal> （オプション）：é…延åˆæœŸåŒ–プãƒã‚ã‚·ã«ä½¿ã†ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’指定ã—ã¾ã™ã€‚ 永続化ã™ã‚‹ã‚¯ãƒ©ã‚¹åãã®ã‚‚ã®ã‚’指定ã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr "<literal>dynamic-update</literal> （オプション〠デフォルト㯠<literal>false</literal> ）： 値ãŒå¤‰æ›´ã•ã‚ŒãŸã‚«ãƒ©ãƒ ã ã‘ã‚’å«ã‚€SQLã® <literal>UPDATE</literal> 文をã€å®Ÿè¡Œæ™‚ã«ç”Ÿæˆã™ã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>dynamic-insert</literal> （オプション, デフォルト㯠<literal>false</literal> ）： 値ãŒnullã§ã¯ãªã„カラムã ã‘ã‚’å«ã‚€SQLã® <literal>INSERT</literal> 文をã€å®Ÿè¡Œæ™‚ã«ç”Ÿæˆã™ã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>select-before-update</literal> (オプション, デフォルト㯠<literal>false</literal>): オブジェクトãŒå¤‰æ›´ã•ã‚ŒãŸã®ãŒç¢ºå®Ÿã§ãªã„ãªã‚‰ã°ã€HibernateãŒSQLã® <literal>UPDATE</literal> ã‚’ <emphasis>決ã—ã¦å®Ÿè¡Œã—ãªã„</emphasis> ã“ã¨ã‚’指定ã—ã¾ã™ã€‚ ã‚る特定ã®å ´åˆ(実際的ã«ã¯ã€ä¸€æ™‚オブジェクト㌠<literal>update()</literal> を使ã„〠新ã—ã„セッションã¨é–¢é€£ä»˜ã‘られãŸæ™‚ã ã‘)ã€<literal>UPDATE</literal> ãŒå®Ÿéš›ã«å¿…è¦ã‹ã©ã†ã‹ã‚’決定ã™ã‚‹ãŸã‚ã«ã€ HibernateãŒä½™åˆ†ãªSQLã® <literal>SELECT</literal> 文を実行ã™ã‚‹ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr "(optional, デフォルトã§ã¯ <literal>implicit</literal> ): implicit（暗黙）ã‹explicit（明示）ã®ã€ ã©ã¡ã‚‰ã®ã‚¯ã‚¨ãƒªãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を使ã†ã‹æ±ºå®šã—ã¾ã™ã€‚"
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr "<literal>where</literal> （オプション）： ã“ã®ã‚¯ãƒ©ã‚¹ã®ã‚ªãƒ–ジェクトを検索ã™ã‚‹ã¨ãã«ä½¿ç”¨ã™ã‚‹ã€ä»»æ„ã®SQLã® <literal>WHERE</literal> æ¡ä»¶ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>persister</literal> （オプション）：カスタム<literal>ClassPersister</literal> を指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>batch-size</literal> （オプション, デフォルト㯠<literal>1</literal> ）： è˜åˆ¥åã§ã“ã®ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’復元ã™ã‚‹ã¨ãã®ã€Œãƒãƒƒãƒã‚µã‚¤ã‚ºã€ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr "<literal>optimistic-lock</literal> （オプション,デフォルト㯠<literal>version</literal> ）： 楽観ãƒãƒƒã‚¯æˆ¦ç•¥ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "<literal>lazy</literal> （オプション）： <literal>lazy=\"false\"</literal> ã¨è¨å®šã™ã‚‹ã“ã¨ã§ã€ é…延フェッãƒãŒã§ããªããªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr "<literal>entity-name</literal> （オプションã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã¯ã‚¯ãƒ©ã‚¹å）： Hibernate3ã§ã¯ã‚¯ãƒ©ã‚¹ãŒè¤‡æ•°å›žãƒžãƒƒãƒ”ングã§ãï¼ˆå ´åˆã«ã‚ˆã£ã¦ã¯é•ã†ãƒ†ãƒ¼ãƒ–ルã«å¯¾ã—ã¦ã‚‚）〠Javaレベルã§Mapã‚„XMLã§è¡¨ç¾ã•ã‚Œã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒžãƒƒãƒ”ングãŒå¯èƒ½ã§ã™ã€‚ ã“れらã®å ´åˆã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã—ã¦ä»»æ„ã®åå‰ã‚’ã€æ˜Žç¤ºçš„ã«ä»˜ã‘ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。 詳ã—ã㯠<xref linkend=\"persistent-classes-dynamicmodels\"/> 㨠<xref linkend=\"xml\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "<literal>check</literal> （オプション）：自動的ã«ã‚¹ã‚ーマを生æˆã™ã‚‹ãŸã‚ã«ã€ 複数行㮠<emphasis>check</emphasis> 制約を生æˆã™ã‚‹SQLå¼ã€‚"
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "<literal>rowid</literal> （オプション）：Hibernateã¯ã€ãれをサãƒãƒ¼ãƒˆã—ã¦ã„るデータベースã§ROWID㨠呼ã°ã‚Œã‚‹ã‚‚ã®ã‚’使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ 例ãˆã°Oracleを使ã£ã¦ã„ã‚‹ã¨ãã€ã“ã®ã‚ªãƒ—ション㫠<literal>rowid</literal> ã‚’è¨å®šã™ã‚Œã°ã€ Hiberanteã¯updateを高速化ã™ã‚‹ãŸã‚ã« <literal>rowid</literal> ã¨ã„ã†ç‰¹åˆ¥ãªã‚«ãƒ©ãƒ を使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ ROWIDã¯è©³ç´°ãªå®Ÿè£…ã§ã‚ã‚Šã€ä¿å˜ã•ã‚ŒãŸã‚¿ãƒ—ルã®ç‰©ç†çš„ãªä½ç½®ã‚’表ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr "<literal>subselect</literal> （オプション）：ä¸å¤‰ã‹ã¤èªã¿å–り専用ã§ã‚るエンティティを データベースã®å‰¯å•åˆã›ï¼ˆsubselect）ã«ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚ ã‚‚ã—å…ƒã®ãƒ†ãƒ¼ãƒ–ルã®ä»£ã‚ã‚Šã«ãƒ“ューをæŒã¡ãŸã‘ã‚Œã°æœ‰ç”¨ã§ã™ãŒã€ ãã†ã§ãªã„ã®ãªã‚‰æœ‰ç”¨ã§ã¯ã‚ã‚Šã¾ã›ã‚“。より詳ã—ã„æƒ…å ±ã¯ä¸‹è¨˜ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr "<literal>abstract</literal> （オプション）： <literal><union-subclass></literal> 階層内ã®æŠ½è±¡ã‚¹ãƒ¼ãƒ‘ークラスã«ãƒžãƒ¼ã‚¯ã™ã‚‹ãŸã‚ã«ä½¿ã„ã¾ã™ã€‚"
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr "永続クラスã®åå‰ã«ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’指定ã—ã¦ã‚‚ã¾ã£ãŸãå•é¡Œã‚ã‚Šã¾ã›ã‚“。 ãã®ã¨ã㯠<literal><subclass></literal> è¦ç´ を使ã£ã¦ã€ ãã®ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã™ã‚‹ã‚¯ãƒ©ã‚¹ã‚’定義ã—ã¦ãã ã•ã„。 <emphasis>static</emphasis> ãªå†…部クラスã§ã‚‚永続化ã§ãã¾ã™ã€‚ ãã®ã¨ãã¯æ¨™æº–å½¢å¼ã€ä¾‹ãˆã° <literal>eg.Foo$Bar</literal> を使ã£ã¦ã‚¯ãƒ©ã‚¹åを指定ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "<literal>mutable=\"false\"</literal> 指定をã—ãŸä¸å¤‰ã‚¯ãƒ©ã‚¹ã¯ã€ アプリケーションã«ã‚ˆã‚‹æ›´æ–°ã‚„削除ãŒå‡ºæ¥ãªã„ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚Šã€HibernateãŒãƒ‘フォーマンスを少ã—改善ã—ã¾ã™ã€‚"
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "オプション㮠<literal>proxy</literal> 属性ã«ã‚ˆã‚Šã€ã‚¯ãƒ©ã‚¹ã®æ°¸ç¶šã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®é…延åˆæœŸåŒ–ãŒå¯èƒ½ã«ãªã‚Šã¾ã™ã€‚ Hibernateã¯æœ€åˆã«ã€æŒ‡å®šã—ãŸã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã—ãŸCGLIBプãƒã‚ã‚·ã‚’è¿”ã—ã¾ã™ã€‚ 実際ã®æ°¸ç¶šã‚ªãƒ–ジェクトã¯ãƒ—ãƒã‚ã‚·ã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’呼ã³å‡ºã™ã¨ãã«ãƒãƒ¼ãƒ‰ã—ã¾ã™ã€‚ 以下ã®ã€Œé…延åˆæœŸåŒ–ã®ãŸã‚ã®ãƒ—ãƒã‚ã‚·ã€ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr "<emphasis>暗黙的</emphasis> ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã¨ã¯ã€æ¬¡ã®äºŒã¤ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚ 一ã¤ã¯ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã€ã‚¹ãƒ¼ãƒ‘ークラスや実装ã—ãŸã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã€ã¾ãŸãã®ã‚¯ãƒ©ã‚¹ã‚’指定ã™ã‚‹ã‚¯ã‚¨ãƒªã«ã‚ˆã£ã¦è¿”ã•ã‚Œã‚‹ã“ã¨ã§ã€ ã‚‚ã†ä¸€ã¤ã¯ãã®ã‚¯ãƒ©ã‚¹ã®ã‚µãƒ–クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã€ãã®ã‚¯ãƒ©ã‚¹è‡ªèº«ã‚’指定ã—ãŸã‚¯ã‚¨ãƒªã«ã‚ˆã£ã¦è¿”ã•ã‚Œã‚‹ã“ã¨ã§ã™ã€‚ ã¾ãŸã€<emphasis>明示的</emphasis> ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã¨ã¯ã€æ¬¡ã®äºŒã¤ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚ 一ã¤ã¯ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã€ãã®ã‚¯ãƒ©ã‚¹ã‚’明示的ã«æŒ‡å®šã—ãŸã‚¯ã‚¨ãƒªã«ã‚ˆã£ã¦ã®ã¿è¿”ã•ã‚Œã‚‹ã“ã¨ã§ã€ ã‚‚ã†ä¸€ã¤ã¯ã‚¯ãƒ©ã‚¹ã‚’指定ã—ãŸã‚¯ã‚¨ãƒªãŒã€<literal><class></literal> è¦ç´ ã®ä¸ã§ <literal><subclass></literal> ã‚„ <literal><joined-subclass></literal> ã¨ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„るサブクラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã ã‘ã‚’è¿”ã™ã“ã!
¨ã§ã™ã€‚ ã»ã¨ã‚“ã©ã®ç”¨é€”ã§ã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã® <literal>polymorphism=\"implicit\"</literal> ãŒé©åˆ‡ã§ã™ã€‚ 明示的ãªãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã¯ã€2ã¤ã®é•ã£ãŸã‚¯ãƒ©ã‚¹ãŒåŒã˜ãƒ†ãƒ¼ãƒ–ルã«ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ã‚‹ã¨ãã«æœ‰ç”¨ã§ã™ （ã“ã‚Œã«ã‚ˆã£ã¦ãƒ†ãƒ¼ãƒ–ルカラムã®ã‚µãƒ–セットをå«ã‚€ã€ã€Œè»½é‡ãªã€ã‚¯ãƒ©ã‚¹ãŒå¯èƒ½ã«ãªã‚Šã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr "<literal>persister</literal> 属性を指定ã™ã‚‹ã“ã¨ã§ã€ã‚¯ãƒ©ã‚¹ã®æ°¸ç¶šåŒ–戦略をカスタマイズã§ãã¾ã™ã€‚ 例ãˆã° <literal>org.hibernate.persister.EntityPersister</literal> 自身ã®ã‚µãƒ–クラスを指定ã—ãŸã‚Šã€ ã¾ãŸä¾‹ãˆã°ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚³ãƒ¼ãƒ«ã€ãƒ•ãƒ©ãƒƒãƒˆãƒ•ã‚¡ã‚¤ãƒ«ã¸ã‚·ãƒªã‚¢ãƒ©ã‚¤ã‚ºã€ LDAPãªã©ã‚’通ã—ãŸæ°¸ç¶šæ€§ã‚’実装ã™ã‚‹ <literal>org.hibernate.persister.ClassPersister</literal> インターフェイスã®å®Œå…¨ã«æ–°ã—ã„実装をæä¾›ã§ãã¾ã™ã€‚ç°¡å˜ãªä¾‹ã¨ã—㦠<literal>org.hibernate.test.CustomPersister</literal> を見ã¦ãã ã•ã„（ã“れ㯠<literal>Hashtable</literal> ã®ã€Œæ°¸ç¶šåŒ–ã€ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr "<literal>dynamic-update</literal> 㨠<literal>dynamic-insert</literal> ã®è¨å®šã¯ã‚µãƒ–クラスã«ç¶™æ‰¿ã•ã‚Œã¾ã›ã‚“。 ãã®ãŸã‚ <literal><subclass></literal> ã‚„ <literal><joined-subclass></literal> è¦ç´ を指定ã™ã‚‹ã“ã¨ã‚‚出æ¥ã¾ã™ã€‚ ã“れらã®è¨å®šã¯ãƒ‘フォーマンスをå‘上ã•ã›ã‚‹äº‹ã‚‚ã‚ã‚Šã¾ã™ãŒã€è½ã¨ã™ã“ã¨ã‚‚ã‚ã‚Šã¾ã™ã®ã§ã€æ…Žé‡ã«ä½¿ç”¨ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "<literal>select-before-update</literal> ã®ä½¿ç”¨ã¯é€šå¸¸ãƒ‘フォーマンスをè½ã¨ã—ã¾ã™ã€‚ ã‚‚ã— <literal>Session</literal> ã¸åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ã‚°ãƒ©ãƒ•ã‚’å†è¿½åŠ ã™ã‚‹ãªã‚‰ã€ データベース更新ã®ãƒˆãƒªã‚¬ã‚’ä¸å¿…è¦ã«å‘¼ã³å‡ºã™ã®ã‚’é¿ã‘ã‚‹ã¨ã„ã†ç‚¹ã§ã€éžå¸¸ã«æœ‰ç”¨ã§ã™ã€‚"
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr "<literal>dynamic-update</literal> を有効ã«ã™ã‚Œã°ã€æ¥½è¦³ãƒãƒƒã‚¯æˆ¦ç•¥ã‚’é¸ã¶ã“ã¨ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr "<literal>version</literal> ãƒãƒ¼ã‚¸ãƒ§ãƒ³/タイムスタンプカラムをãƒã‚§ãƒƒã‚¯ã—ã¾ã™"
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr "<literal>all</literal> ã™ã¹ã¦ã®ã‚«ãƒ©ãƒ ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚"
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr "<literal>dirty</literal> 変更ã—ãŸã‚«ãƒ©ãƒ ã‚’ãƒã‚§ãƒƒã‚¯ã—ã€åŒæ™‚æ›´æ–°ã§ãるよã†ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr "<literal>none</literal> 楽観ãƒãƒƒã‚¯ã‚’使用ã—ã¾ã›ã‚“"
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr "Hibernateã§æ¥½è¦³çš„ãƒãƒƒã‚¯æˆ¦ç•¥ã‚’使ã†ãªã‚‰ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³/タイムスタンプカラムを使ã†ã“ã¨ã‚’ <emphasis> éžå¸¸ã«</emphasis> å¼·ããŠå‹§ã‚ã—ã¾ã™ã€‚ 楽観的ãƒãƒƒã‚¯ã¯ãƒ‘フォーマンスã®è¦³ç‚¹ã‹ã‚‰ã‚‚最é©ã§ã‚ã‚Šã€ã•ã‚‰ã«åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¸ã®ä¿®æ£ （ã¤ã¾ã‚Š <literal>Session.marge()</literal> ãŒä½¿ã‚れるã¨ã） ã‚’æ£ç¢ºã«æ‰±ã†ã“ã¨ã®ã§ãる唯一ã®æˆ¦ç•¥ã§ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "Hibernateã®ãƒžãƒƒãƒ”ングã«ã¨ã£ã¦ãƒ“ューã¨æ™®é€šã®ãƒ†ãƒ¼ãƒ–ルã®é–“ã«é•ã„ã¯ãªã〠データベースレベルã§ã¯é€éŽçš„ã§ã™ （ãŸã ã—ビューを完全ã«ã¯ã‚µãƒãƒ¼ãƒˆã—ã¦ã„ãªã„DBMSã‚‚ã‚ã‚Šã¾ã™ã€‚ 特ã«ã€æ›´æ–°ã®ã‚るビューã«å¯¾ã—ã¦ã¯ãã†ã§ã™ï¼‰ã€‚ ビューを使ã„ãŸãã¦ã‚‚ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã§ä½œæˆã§ããªã„ã“ã¨ãŒã‚ã‚Šã¾ã™ （例ãˆã°ã€ãƒ¬ã‚¬ã‚·ãƒ¼ã‚¹ã‚ーマã®å ´åˆï¼‰ã€‚ ã“ã®å ´åˆã«ã¯ã€ä¸å¤‰ã‹ã¤èªã¿å–り専用ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«ä¸Žãˆã‚‰ã‚ŒãŸSQLã®å‰¯å•åˆã›æ–‡ã‚’マップã§ãã¾ã™ã€‚"
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Summary\">
+\n"
+ " <subselect>
+\n"
+ " select item.name, max(bid.amount), count(*)
+\n"
+ " from item
+\n"
+ " join bid on bid.item_id = item.id
+\n"
+ " group by item.name
+\n"
+ " </subselect>
+\n"
+ " <synchronize table=\"item\"/>
+\n"
+ " <synchronize table=\"bid\"/>
+\n"
+ " <id name=\"name\"/>
+\n"
+ " ...
+\n"
+ "</class>]]>"
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr "テーブルをã“ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨åŒæœŸã™ã‚‹ã‚ˆã†ã«å®šç¾©ã—ã¦ãã ã•ã„。 オートフラッシュãŒç¢ºå®Ÿã«èµ·ã“るよã†ã«ã€ã¾ãŸå°Žå‡ºã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã™ã‚‹ã‚¯ã‚¨ãƒªãŒå¤ã„データを è¿”ã•ãªã„よã†ã«ã™ã‚‹ãŸã‚ã§ã™ã€‚ <literal><subselect></literal> ã¯å±žæ€§ã¨ãƒã‚¹ãƒˆã—ãŸãƒžãƒƒãƒ”ング属性ã®ã©ã¡ã‚‰ã§ã‚‚利用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr "<title>id</title>"
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr "マップã•ã‚ŒãŸã‚¯ãƒ©ã‚¹ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルã®ä¸»ã‚ーカラムを定義 <emphasis>ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“</emphasis> 。 ã»ã¨ã‚“ã©ã®ã‚¯ãƒ©ã‚¹ã«ã¯ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åã‚’ä¿æŒã™ã‚‹JavaBeansスタイルã®ãƒ—ãƒãƒ‘ティもã‚ã‚Šã¾ã™ã€‚ <literal><id></literal> è¦ç´ ã¯ã€ãã®ãƒ—ãƒãƒ‘ティã‹ã‚‰ä¸»ã‚ーカラムã¸ã®ãƒžãƒƒãƒ”ングを定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id
+\n"
+ " name=\"propertyName\"
+\n"
+ " type=\"typename\"
+\n"
+ " column=\"column_name\"
+\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"
+\n"
+ " access=\"field|property|ClassName\">
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ "
+\n"
+ " <generator class=\"generatorClass\"/>
+\n"
+ "</id>]]>"
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr "<literal>name</literal>（オプション）：è˜åˆ¥åプãƒãƒ‘ティã®åå‰ã€‚"
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr "<literal>type</literal>（オプション）：Hibernateã®åž‹ã‚’示ã™åå‰ã€‚"
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr "<literal>column</literal>（オプション - デフォルトã¯ãƒ—ãƒãƒ‘ティå）： 主ã‚ーカラムã®åå‰ã€‚"
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr "<literal>unsaved-value</literal>（オプション - デフォルトã®å€¤ã¯sensible）： インスタンスãŒæ–°ã—ãインスタンス化ã•ã‚ŒãŸ （セーブã•ã‚Œã¦ã„ãªã„）ã“ã¨ã‚’示ã™ã€è˜åˆ¥åプãƒãƒ‘ティã®å€¤ã€‚ 以å‰ã®Sessionã§ã‚»ãƒ¼ãƒ–ã¾ãŸã¯ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸä¸€æ™‚的インスタンスã¨åŒºåˆ¥ã™ã‚‹ãŸã‚㫠使ã„ã¾ã™ã€‚"
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr "<literal>access</literal>（オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã§ã™ã€‚"
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr "<literal>name</literal> 属性ãŒãªã‘ã‚Œã°ã€ã‚¯ãƒ©ã‚¹ã«ã¯è˜åˆ¥åプãƒãƒ‘ティãŒãªã„ã‚‚ã®ã¨ã¿ãªã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr "<literal>unsaved-value</literal> 属性ã¯Hibernate3ã§ã¯ã»ã¨ã‚“ã©ã®å ´åˆã€å¿…è¦ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr "複åˆã‚ーをæŒã¤ãƒ¬ã‚¬ã‚·ãƒ¼ãƒ‡ãƒ¼ã‚¿ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãるよã†ã«ã€ <literal><composite-id></literal> ã¨ã„ã†ä»£æ›¿ã®ãƒžãƒƒãƒ”ング定義ãŒã‚ã‚Šã¾ã™ã€‚ ã—ã‹ã—ä»–ã®ç”¨é€”ã¸ã®ä½¿ç”¨ã¯å…¨ããŠã™ã™ã‚ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:532
+msgid "Generator"
+msgstr "ジェãƒãƒ¬ãƒ¼ã‚¿"
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr "オプション㮠<literal><generator></literal> åè¦ç´ ã¯ã€ 永続クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åを生æˆã™ã‚‹ãŸã‚ã«ä½¿ã†ã€Javaクラスを指定ã—ã¾ã™ã€‚ ジェãƒãƒ¬ãƒ¼ã‚¿ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®è¨å®šã€ã‚‚ã—ãã¯åˆæœŸåŒ–ã«ãƒ‘ラメータãŒå¿…è¦ã§ã‚ã‚Œã°ã€<literal><param></literal> è¦ç´ を使ã£ã¦æ¸¡ã™ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">
+\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">
+\n"
+ " <param name=\"table\">uid_table</param>
+\n"
+ " <param name=\"column\">next_hi_value_column</param>
+\n"
+ " </generator>
+\n"
+ "</id>]]>"
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr "ã™ã¹ã¦ã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã¯ã€ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ <literal>org.hibernate.id.IdentifierGenerator</literal> を実装ã—ã¾ã™ã€‚ ã“ã‚Œã¯ã¨ã¦ã‚‚å˜ç´”ãªã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ãªã®ã§ã€ç‰¹åˆ¥ãªå®Ÿè£…を独自ã«ç”¨æ„ã™ã‚‹ã‚¢ãƒ—リケーションもã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã—ã‹ã—Hibernateã¯çµ„ã¿è¾¼ã¿ã®å®Ÿè£…ã‚’ã„ãã¤ã‚‚用æ„ã—ã¦ã„ã¾ã™ã€‚ 組ã¿è¾¼ã¿ã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã«ã¯ä»¥ä¸‹ã®ã‚·ãƒ§ãƒ¼ãƒˆã‚«ãƒƒãƒˆåãŒã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:551
+msgid "increment"
+msgstr "increment"
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "<literal>long</literal> , <literal>short</literal> , <literal>int</literal> åž‹ã®è˜åˆ¥åを生æˆã—ã¾ã™ã€‚ ã“れらã¯ä»–ã®ãƒ—ãƒã‚»ã‚¹ãŒåŒã˜ãƒ†ãƒ¼ãƒ–ルã«ãƒ‡ãƒ¼ã‚¿ã‚’挿入ã—ãªã„ã¨ãã ã‘ユニークã§ã™ã€‚ <emphasis>クラスタ内ã§ã¯ä½¿ã‚ãªã„ã§ãã ã•ã„</emphasis> 。"
+
+#: index.docbook:562
+msgid "identity"
+msgstr "identity"
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "DB2, MySQL, MS SQL Server, Sybase, HypersonicSQLã®è˜åˆ¥åカラムを サãƒãƒ¼ãƒˆã—ã¾ã™ã€‚ è¿”ã•ã‚Œã‚‹è˜åˆ¥åã®åž‹ã¯ <literal>long</literal> , <literal>short</literal> , <literal>int</literal> ã®ã„ãšã‚Œã‹ã§ã™ã€‚"
+
+#: index.docbook:572
+msgid "sequence"
+msgstr "sequence"
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "DB2, PostgreSQL, Oracle, SAP DB, McKoiã®ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚„ã€Interbaseã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã‚’使用ã—ã¾ã™ã€‚ è¿”ã•ã‚Œã‚‹è˜åˆ¥åã®åž‹ã¯ <literal>long</literal> , <literal>short</literal> , <literal>int</literal> ã®ã„ãšã‚Œã‹ã§ã™ã€‚"
+
+#: index.docbook:582
+msgid "hilo"
+msgstr "hilo"
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "<literal>long</literal> , <literal>short</literal> , <literal>int</literal> åž‹ã®è˜åˆ¥åを効率的ã«ç”Ÿæˆã™ã‚‹hi/loアルゴリズムを使ã„ã¾ã™ã€‚ hi値ã®ã‚½ãƒ¼ã‚¹ã¨ã—ã¦ã€ãƒ†ãƒ¼ãƒ–ルã¨ã‚«ãƒ©ãƒ を与ãˆã¾ã™(デフォルトã§ã¯ãã‚Œãžã‚Œ <literal>hibernate_unique_key</literal> 㨠<literal>next_hi</literal> )。 hi/loアルゴリズムã¯ç‰¹å®šã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«å¯¾ã—ã¦ã®ã¿ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åを生æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr "seqhilo"
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "<literal>long</literal> , <literal>short</literal> , <literal>int</literal> åž‹ã®è˜åˆ¥åを効率的ã«ç”Ÿæˆã™ã‚‹hi/loアルゴリズムを使ã„ã¾ã™ã€‚ 指定ã•ã‚ŒãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚’与ãˆã¾ã™ã€‚"
+
+#: index.docbook:604
+msgid "uuid"
+msgstr "uuid"
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr "(IPアドレスãŒä½¿ç”¨ã•ã‚Œã‚‹)ãƒãƒƒãƒˆãƒ¯ãƒ¼ã‚¯å†…ã§ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªæ–‡å—列型ã®è˜åˆ¥åを生æˆã™ã‚‹ãŸã‚ã«ã€ 128ビットã®UUIDアルゴリズムを使用ã—ã¾ã™ã€‚UUIDã¯é•·ã•32ã®16進数å—ã®æ–‡å—列ã¨ã—ã¦ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‰ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:614
+msgid "guid"
+msgstr "guid"
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr "MS SQLサーãƒã¨MySQLã§ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒç”Ÿæˆã™ã‚‹GUIDæ–‡å—列を使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:622
+msgid "native"
+msgstr "native"
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®æ€§èƒ½ã«ã‚ˆã‚Š <literal>identity</literal> , <literal>sequence</literal> , <literal>hilo</literal> ã®ã„ãšã‚Œã‹ãŒé¸ã°ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:632
+msgid "assigned"
+msgstr "assigned"
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr "<literal>save()</literal> ãŒå‘¼ã°ã‚Œã‚‹å‰ã«ã€ アプリケーションãŒã‚ªãƒ–ジェクトã«è˜åˆ¥åを代入ã§ãるよã†ã«ã—ã¾ã™ã€‚ <literal><generator></literal> ãŒæŒ‡å®šã•ã‚Œã¦ã„ãªã‘ã‚Œã°ã€ã“ã‚ŒãŒãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®æˆ¦ç•¥ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:642
+msgid "select"
+msgstr "select"
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr "ã‚るユニークã‚ーã«ã‚ˆã‚‹è¡Œã®é¸æŠžã¨ä¸»ã‚ーã®å€¤ã®å¾©å…ƒã«ã‚ˆã‚Šã€ データベーストリガãŒå‰²ã‚Šå½“ã¦ãŸä¸»ã‚ーをå–å¾—ã—ã¾ã™ã€‚"
+
+#: index.docbook:651
+msgid "foreign"
+msgstr "foreign"
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr "ä»–ã®é–¢é€£ã‚ªãƒ–ジェクトã®è˜åˆ¥åを使ã„ã¾ã™ã€‚ 普通ã¯ã€<literal><one-to-one></literal> 主ã‚ー関連ã¨çµ„ã¿åˆã‚ã›ã¦ä½¿ã„ã¾ã™ã€‚"
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr "Hi/lo アルゴリズム"
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "<literal>hilo</literal> 㨠<literal>seqhilo</literal> ジェãƒãƒ¬ãƒ¼ã‚¿ã¯ã€ è˜åˆ¥å生æˆã®ä»£è¡¨çš„ãªã‚¢ãƒ—ãƒãƒ¼ãƒã§ã‚ã‚‹hi/loアルゴリズムã®2ã¤ã®ä»£æ›¿å®Ÿè£…ã‚’æä¾›ã—ã¾ã™ã€‚ 1番目ã®å®Ÿè£…ã¯ã€æ¬¡å›žã«åˆ©ç”¨ã•ã‚Œã‚‹\"hi\"値をä¿æŒã™ã‚‹ã€Œç‰¹åˆ¥ãªã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルを å¿…è¦ã¨ã—ã¾ã™ã€‚ 2番目ã®å®Ÿè£…ã¯ã€Oracleスタイルã®ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã‚’使ã„ã¾ã™ï¼ˆã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã‚‹å ´åˆï¼‰ã€‚"
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">
+\n"
+ " <generator class=\"hilo\">
+\n"
+ " <param name=\"table\">hi_value</param>
+\n"
+ " <param name=\"column\">next_value</param>
+\n"
+ " <param name=\"max_lo\">100</param>
+\n"
+ " </generator>
+\n"
+ "</id>]]>"
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">
+\n"
+ " <generator class=\"seqhilo\">
+\n"
+ " <param name=\"sequence\">hi_value</param>
+\n"
+ " <param name=\"max_lo\">100</param>
+\n"
+ " </generator>
+\n"
+ "</id>]]>"
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "残念ãªãŒã‚‰Hibernateã¸ã®ç‹¬è‡ªã® <literal>Connection</literal> ã‚’æä¾›ã™ã‚‹ã¨ãã«ã¯ã€<literal>hilo</literal> を使ãˆã¾ã›ã‚“。 HibernateãŒJTAã§ãƒªã‚¹ãƒˆã•ã‚Œã¦ã„る接続をå–å¾—ã™ã‚‹ãŸã‚ã«ã‚¢ãƒ—リケーションサーãƒãƒ¼ã®ãƒ‡ãƒ¼ã‚¿ã‚½ãƒ¼ã‚¹ã‚’使用ã—ã¦ã„ã‚‹ã¨ãã«ã¯ã€ <literal>hibernate.transaction.manager_lookup_class</literal> ã‚’é©åˆ‡ã«è¨å®šã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "UUID アルゴリズム"
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "UUIDã«ã¯ä»¥ä¸‹ã®ã‚‚ã®ãŒå«ã¾ã‚Œã¾ã™ï¼š IPアドレスã€JVMã®ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—タイム（4分ã®1秒ã®æ£ç¢ºã•ï¼‰ã€ システム時間ã€ï¼ˆJVMã«å¯¾ã—ã¦ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªï¼‰ã‚«ã‚¦ãƒ³ã‚¿å€¤ã€‚ Javaコードã‹ã‚‰MACアドレスやメモリアドレスをå–å¾—ã™ã‚‹ã“ã¨ã¯ã§ããªã„ã®ã§ã€ JNIãŒä½¿ãˆãªã„ã¨ãã®æœ€è‰¯ã®æ–¹æ³•ã§ã™ã€‚"
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr "è˜åˆ¥åカラムã¨ã‚·ãƒ¼ã‚±ãƒ³ã‚¹"
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr "è˜åˆ¥åカラムをサãƒãƒ¼ãƒˆã—ã¦ã„るデータベース（DB2, MySQL, Sybase, MS SQL）ã§ã¯ã€ <literal>identity</literal> ã‚ー生æˆã‚’使ãˆã¾ã™ã€‚ シーケンスをサãƒãƒ¼ãƒˆã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ï¼ˆDB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB）ã§ã¯ã€ <literal>sequence</literal> スタイルã®ã‚ー生æˆã‚’使ãˆã¾ã™ã€‚ ã©ã¡ã‚‰ã®æˆ¦ç•¥ã‚‚ã€æ–°ã—ã„オブジェクトを挿入ã™ã‚‹ãŸã‚ã«ã€SQLクエリを2ã¤å¿…è¦ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">
+\n"
+ " <generator class=\"sequence\">
+\n"
+ " <param name=\"sequence\">person_id_sequence</param>
+\n"
+ " </generator>
+\n"
+ "</id>]]>"
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">
+\n"
+ " <generator class=\"identity\"/>
+\n"
+ "</id>]]>"
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "クãƒã‚¹ãƒ—ラットフォームã®é–‹ç™ºã§ã¯ã€<literal>native</literal> 戦略㯠<literal>identity</literal> , <literal>sequence</literal> , <literal>hilo</literal> 戦略ã®ä¸ã‹ã‚‰1ã¤ã‚’é¸æŠžã—ã¾ã™ãŒã€ ã“ã‚Œã¯ä½¿ç”¨ã—ã¦ã„るデータベースã®èƒ½åŠ›ã«ä¾å˜ã—ã¾ã™ã€‚"
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr "è˜åˆ¥åã®å‰²ã‚Šå½“ã¦"
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr "アプリケーションã«è˜åˆ¥åを割り当ã¦ã•ã›ãŸã„ã®ã§ã‚ã‚Œã°(HibernateãŒç”Ÿæˆã™ã‚‹ã‚‚ã®ã§ã¯ãªã）〠<literal>assigned</literal> ジェãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã®ç‰¹åˆ¥ãªã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã¯ã€ã™ã§ã«ã‚ªãƒ–ジェクトã®è˜åˆ¥åプãƒãƒ‘ティã«ä»£å…¥ã•ã‚ŒãŸå€¤ã‚’ è˜åˆ¥åã«ä½¿ã„ã¾ã™ã€‚ã“ã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã¯ä¸»ã‚ーãŒä»£ç†ã‚ーã®ä»£ã‚ã‚Šã«è‡ªç„¶ã‚ーã§ã‚ã‚‹å ´åˆã«ä½¿ç”¨ã—ã¾ã™ã€‚ <literal><generator></literal> è¦ç´ を指定ã—ãªã„å ´åˆã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®å‹•ä½œã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr "<literal>assigned</literal> ジェãƒãƒ¬ãƒ¼ã‚¿ã‚’é¸æŠžã™ã‚‹ã¨ã€ Hibernate㯠<literal>unsaved-value=\"undefined\"</literal> を使用ã—ã¾ã™ã€‚ ãã—ã¦ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚„タイムスタンプã®ãƒ—ãƒãƒ‘ティãŒãªã„å ´åˆã‚„ <literal>Interceptor.isUnsaved()</literal> を定義ã—ãªã‹ã£ãŸå ´åˆã«ã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒä¸€æ™‚çš„(transient)ãªã‚‚ã®ã§ã‚ã‚‹ã®ã‹ã€ ã¾ãŸã¯ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‹ã‚‰åˆ†é›¢(detached)ã—ãŸã‚‚ã®ã‹ã©ã†ã‹ã‚’決ã‚ã‚‹ãŸã‚ã«ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’調ã¹ã¾ã™ã€‚"
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr "トリガã«ã‚ˆã‚Šå‰²ã‚Šå½“ã¦ã‚‰ã‚ŒãŸä¸»ã‚ー"
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr "レガシースã‚ーマã®ãŸã‚ã«ã®ã¿æŒ‡å®šã—ã¾ã™(Hibernateã¯ãƒˆãƒªã‚¬ã‚’使ã£ã¦DDLを生æˆã—ã¾ã›ã‚“)。"
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">
+\n"
+ " <generator class=\"select\">
+\n"
+ " <param name=\"key\">socialSecurityNumber</param>
+\n"
+ " </generator>
+\n"
+ "</id>]]>"
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr "上ã®ä¾‹ã®ä¸ã§ã€ã‚¯ãƒ©ã‚¹ã§è‡ªç„¶ã‚ーã¨ã—ã¦å®šç¾©ã•ã‚ŒãŸ <literal>socialSecurityNumber</literal> ã¨ã„ã†åå‰ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªå€¤ã®ãƒ—ãƒãƒ‘ティã¨ã€ 値ãŒãƒˆãƒªã‚¬ã«ã‚ˆã‚Šç”Ÿæˆã•ã‚Œã‚‹ <literal>person_id</literal> ã¨ã„ã†åå‰ã®ä»£ç†ã‚ーãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr "composite-id"
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr ""
+ "<![CDATA[<composite-id
+\n"
+ " name=\"propertyName\"
+\n"
+ " class=\"ClassName\"
+\n"
+ " mapped=\"true|false\"
+\n"
+ " access=\"field|property|ClassName\">
+\n"
+ " node=\"element-name|.\"
+\n"
+ "
+\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>
+\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>
+\n"
+ " ......
+\n"
+ "</composite-id>]]>"
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr "複åˆã‚ーã®ã‚るテーブルã«å¯¾ã—〠è˜åˆ¥åプãƒãƒ‘ティã¨ã—ã¦ã‚¯ãƒ©ã‚¹ã®è¤‡æ•°ã®ãƒ—ãƒãƒ‘ティをマッピングã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal><composite-id></literal> è¦ç´ ã¯ã€åè¦ç´ ã¨ã—㦠<literal><key-property></literal> プãƒãƒ‘ティマッピング㨠<literal><key-many-to-one></literal> マッピングをå—ã‘入れã¾ã™ã€‚"
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr ""
+ "<![CDATA[<composite-id>
+\n"
+ " <key-property name=\"medicareNumber\"/>
+\n"
+ " <key-property name=\"dependent\"/>
+\n"
+ "</composite-id>]]>"
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr "複åˆè˜åˆ¥åã®ç‰ä¾¡æ€§ã‚’実装ã™ã‚‹ãŸã‚ã«ã¯ã€æ°¸ç¶šã‚¯ãƒ©ã‚¹ãŒ <literal>equals()</literal> 㨠<literal>hashCode()</literal> をオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ <emphasis>ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“</emphasis> 。 ã¾ãŸ <literal>Serializable</literal> も実装ã—ãªã‘ã‚Œã°ã„ã‘ã¾ã›ã‚“。"
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr "残念ãªãŒã‚‰è¤‡åˆè˜åˆ¥åã®ãŸã‚ã®ã“ã®æ–¹æ³•ã¯ã€ 永続オブジェクトãŒè‡ªèº«ã®è˜åˆ¥åã§ã‚ã‚‹ã“ã¨ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚ オブジェクト自身をè˜åˆ¥åã¨ã™ã‚‹ä»¥ä¸Šã®ä¾¿åˆ©ãªã€Œæ‰±ã„æ–¹ã€ã¯ã‚ã‚Šã¾ã›ã‚“。 複åˆã‚ーã«é–¢é€£ã—ãŸæ°¸ç¶šçŠ¶æ…‹ã‚’ <literal>load()</literal> 出æ¥ã‚‹ã‚ˆã†ã«ãªã‚‹å‰ã«ã€ 永続クラス自身をインスタンス化ã—ã€è˜åˆ¥åプãƒãƒ‘ティをè¨å®šã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <emphasis> 組ã¿è¾¼ã¿ã®</emphasis> 複åˆè˜åˆ¥åã¨å‘¼ã°ã‚Œã‚‹ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€ æœ¬æ ¼çš„ãªã‚¢ãƒ—リケーションã«ã¯å‘ã„ã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr "2ã¤ç›®ã®æ–¹æ³•ã¯ <emphasis> マップã•ã‚ŒãŸ</emphasis> 複åˆè˜åˆ¥åã¨å‘¼ã°ã‚Œã‚‹ã‚‚ã®ã§ã€ <literal><composite-id></literal>エレメント内ã§æŒ‡å®šã—ãŸè˜åˆ¥ãƒ—ãƒãƒ‘ティ㌠永続クラスã¨åˆ†é›¢ã—ãŸè˜åˆ¥åクラスã®ä¸¡æ–¹ã«é‡è¤‡ã—ã¦å˜åœ¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">
+\n"
+ " <key-property name=\"medicareNumber\"/>
+\n"
+ " <key-property name=\"dependent\"/>
+\n"
+ "</composite-id>]]>"
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "ã“ã®ä¾‹ã§ã¯ã€è¤‡åˆè˜åˆ¥åクラス（ <literal>MedicareId</literal> ）ã¨ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹è‡ªèº«ã®ä¸¡æ–¹ãŒã€ <literal>medicareNumber</literal> 㨠<literal>dependent</literal> ã¨ã„ã†åå‰ã®ãƒ—ãƒãƒ‘ティをæŒã¡ã¾ã™ã€‚ è˜åˆ¥åクラスã¯ã€<literal>equals()</literal> 㨠<literal>hashCode()</literal> をオーãƒãƒ©ã‚¤ãƒ‰ã—〠<literal>Serializable</literal> を実装ã—ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。 ã“ã®æ–¹æ³•ã«ã¯ã€æ˜Žã‚‰ã‹ã«ã‚³ãƒ¼ãƒ‰ãŒé‡è¤‡ã™ã‚‹ã¨ã„ã†ä¸éƒ½åˆãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr "次ã®å±žæ€§ã¯ãƒžãƒƒãƒ”ングã—ãŸè¤‡åˆè˜åˆ¥åを指定ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr "<literal>mapped</literal> (オプションã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã¯ <literal>false</literal> ): マッピングã—ãŸè¤‡åˆè˜åˆ¥åãŒä½¿ç”¨ã•ã‚Œã‚‹ã“ã¨ã¨ã€åŒ…å«ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã®ãƒžãƒƒãƒ”ングãŒã€ エンティティクラスã¨è¤‡åˆè˜åˆ¥åクラスã®ä¸¡æ–¹ã‚’å‚ç…§ã™ã‚‹ã“ã¨ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "<literal>class</literal> (オプション,ãŸã ã—マッピングã—ãŸè¤‡åˆè˜åˆ¥åã«ã¯å¿…é ˆ): 複åˆè˜åˆ¥åã¨ã—ã¦ä½¿ç”¨ã™ã‚‹ã‚¯ãƒ©ã‚¹ã€‚"
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr "3ã¤ç›®ã®ã•ã‚‰ã«ä¾¿åˆ©ãªæ–¹æ³•ã¯ã€è¤‡åˆè˜åˆ¥åã‚’<xref linkend=\"components-compositeid\"/>内㮠コンãƒãƒ¼ãƒãƒ³ãƒˆã‚¯ãƒ©ã‚¹ã¨ã—ã¦å®Ÿè£…ã™ã‚‹ã“ã¨ã§ã™ã€‚ 下ã§è¨˜è¿°ã—ã¦ã„る属性ã¯ã€ã“ã®ä»£æ›¿æ–¹æ³•ã«ã®ã¿é©ç”¨ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr "<literal>name</literal> (オプション, ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã¯å¿…é ˆ): 複åˆè˜åˆ¥åã‚’ä¿æŒã™ã‚‹ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚¿ã‚¤ãƒ—ã®ãƒ—ãƒãƒ‘ティ(9ç« ã‚’å‚ç…§ã—ã¦ãã ã•ã„)."
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr "<literal>access</literal> (オプション - デフォルト㯠<literal>property</literal> ): HibernateãŒãƒ—ãƒãƒ‘ティã®å€¤ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã™ã¹ã戦略。"
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr "<literal>class</literal> （オプション - デフォルトã¯ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã‚ˆã‚Šæ±ºå®šã•ã‚Œã‚‹ãƒ—ãƒãƒ‘ティã®åž‹ï¼‰ï¼š 複åˆè˜åˆ¥åã¨ã—ã¦ä½¿ã‚れるコンãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚¯ãƒ©ã‚¹ï¼ˆæ¬¡ã®ç¯€ã‚’見ã¦ãã ã•ã„）。"
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr "ã“ã®3ã¤ç›®ã®æ–¹æ³•ã¯ <emphasis> è˜åˆ¥åコンãƒãƒ¼ãƒãƒ³ãƒˆ</emphasis> ã¨å‘¼ã³ã€ ã»ã¨ã‚“ã©ã™ã¹ã¦ã®ã‚¢ãƒ—リケーションã«å¯¾ã—ã¦æŽ¨å¥¨ã™ã‚‹æ–¹æ³•ã§ã™ã€‚"
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr "discriminator"
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr "<literal><discriminator></literal> è¦ç´ ã¯ã€ table-per-class-hierarchyマッピング戦略を使ã†ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªæ°¸ç¶šåŒ–ã«å¿…è¦ã§ã‚り〠テーブルã®è˜åˆ¥ã‚«ãƒ©ãƒ を定義ã—ã¾ã™ã€‚ è˜åˆ¥ã‚«ãƒ©ãƒ ã¯ã€ã‚ã‚‹è¡Œã«å¯¾ã—ã¦æ°¸ç¶šå±¤ãŒã©ã®ã‚µãƒ–クラスをインスタンス化ã™ã‚‹ã‹ã‚’ ä¼ãˆã‚‹ãƒžãƒ¼ã‚«ãƒ¼å€¤ã‚’å«ã‚“ã§ã„ã¾ã™ã€‚ 以下ã®ã‚ˆã†ãªåž‹ã«åˆ¶é™ã•ã‚Œã¾ã™ï¼š <literal>string</literal> , <literal>character</literal> , <literal>integer</literal>, <literal>byte</literal> , <literal>short</literal> , <literal>boolean</literal> , <literal>yes_no</literal> , <literal>true_false</literal>."
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr ""
+ "<![CDATA[<discriminator
+\n"
+ " column=\"discriminator_column\"
+\n"
+ " type=\"discriminator_type\"
+\n"
+ " force=\"true|false\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " formula=\"arbitrary sql expression\"
+\n"
+ "/>]]>"
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr "<literal>column</literal>（オプション - デフォルト㯠<literal>class</literal> ）： è˜åˆ¥ã‚«ãƒ©ãƒ ã®åå‰ã€‚"
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr "<literal>type</literal> （オプション - デフォルト㯠<literal>string</literal> ）：Hibernateã®åž‹ã‚’示ã™åå‰ã€‚"
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr "<literal>force</literal> （オプション - デフォルト㯠<literal>false</literal> ）： ルートクラスã®ã™ã¹ã¦ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’検索ã™ã‚‹å ´åˆã§ã‚ã£ã¦ã‚‚〠HibernateãŒä½¿ç”¨ã§ãã‚‹è˜åˆ¥ã‚«ãƒ©ãƒ ã®æŒ‡å®šã‚’「強制ã€ã—ã¾ã™ã€‚"
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr "<literal>insert</literal> （オプション - デフォルト㯠<literal>true</literal> ）： ã‚‚ã—è˜åˆ¥ã‚«ãƒ©ãƒ ãŒãƒžãƒƒãƒ”ングã™ã‚‹è¤‡åˆè˜åˆ¥åã®ä¸€éƒ¨ãªã‚‰ã°ã€<literal>false</literal> ã¨è¨å®šã—ã¦ãã ã•ã„。 (Hibernateã«SQLã® <literal>INSERT</literal> ã«ã¯å«ã¾ã‚Œãªã„ã“ã¨ã‚’知らã›ã‚‹)"
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr "<literal>formula</literal> (オプション)åž‹ãŒè©•ä¾¡ã•ã‚Œã‚‹ã¨ãã«å®Ÿè¡Œã•ã‚Œã‚‹ä»»æ„ã®SQLå¼ã€‚ コンテンツベースã®è˜åˆ¥ã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr "è˜åˆ¥ã‚«ãƒ©ãƒ ã®å®Ÿéš›ã®å€¤ã¯ã€ <literal><class></literal> 㨠<literal><subclass></literal> è¦ç´ ã® <literal>discriminator-value</literal> 属性ã§æŒ‡å®šã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr "永続クラスã¸ãƒžãƒƒãƒ”ングã•ã‚Œãªã„｢余分ãªã€è˜åˆ¥å€¤ã‚’æŒã¤è¡ŒãŒ テーブルã«ã‚ã‚Œã°ã€ï¼ˆãã®ã¨ãã«é™ã‚Šï¼‰<literal>force</literal> 属性ã¯æœ‰åŠ¹ã§ã™ã€‚ ãŸã ã—ã€æ™®é€šã¯ãã†ã„ã†ã“ã¨ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr "<literal>formula</literal> 属性を使ã†ã¨ã€è¡Œã®åž‹ã‚’評価ã™ã‚‹ãŸã‚ã«ä»»æ„ã®SQLå¼ã‚’宣言ã§ãã¾ã™ã€‚"
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr ""
+ "<![CDATA[<discriminator
+\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"
+\n"
+ " type=\"integer\"/>]]>"
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr "version（オプション）"
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr "<literal><version></literal> è¦ç´ ã¯ã‚ªãƒ—ションã§ã‚り〠テーブルãŒãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ‡ãƒ¼ã‚¿ã‚’å«ã‚€ã“ã¨ã‚’示ã—ã¾ã™ã€‚ ã“れ㯠<emphasis>ãƒãƒ³ã‚°ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³</emphasis> を使ã†ã¤ã‚‚ã‚Šãªã‚‰ã€ç‰¹ã«å½¹ç«‹ã¡ã¾ã™ï¼ˆä»¥ä¸‹ã‚’見ã¦ãã ã•ã„）。"
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr ""
+ "<![CDATA[<version
+\n"
+ " column=\"version_column\"
+\n"
+ " name=\"propertyName\"
+\n"
+ " type=\"typename\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " unsaved-value=\"null|negative|undefined\"
+\n"
+ " generated=\"never|always\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ "/>]]>"
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal>column</literal>（オプション - デフォルトã¯ãƒ—ãƒãƒ‘ティå）: ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã‚’ä¿æŒã™ã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã€‚"
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr "<literal>name</literal> ：永続クラスã®ãƒ—ãƒãƒ‘ティã®åå‰ã€‚"
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr "<literal>type</literal> （オプション - デフォルト㯠<literal>integer</literal> ）：ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã®åž‹ã€‚"
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "<literal>access</literal> （オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr "<literal>unsaved-value</literal> （オプション - デフォルト㯠<literal>undefined</literal> ）： インスタンスãŒæ–°ã—ãインスタンス化ã•ã‚ŒãŸã“ã¨ã‚’示㙠（セーブã•ã‚Œã¦ã„ãªã„ã“ã¨ã‚’示ã™ï¼‰ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティã®å€¤ã€‚ 以å‰ã®Sessionã§ã‚»ãƒ¼ãƒ–ã¾ãŸã¯ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸä¸€æ™‚çš„ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¨åŒºåˆ¥ã™ã‚‹ãŸã‚㫠使ã„ã¾ã™ã€‚ （ <literal>undefined</literal> ã¯è˜åˆ¥åプãƒãƒ‘ティã®å€¤ãŒä½¿ã‚れるã“ã¨ã‚’指定ã—ã¾ã™ã€‚）"
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr "<literal>generated</literal> (オプション - デフォルト㯠<literal>never</literal> ): ã“ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ãƒ—ãƒãƒ‘ティã®å€¤ãŒã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚ˆã£ã¦ç”Ÿæˆã•ã‚ŒãŸã“ã¨ã‚’指定ã—ã¾ã™ã€‚ <xref linkend=\"mapping-generated\"/>生æˆãƒ—ãƒãƒ‘ティ ã®è°è«–を見ã¦ãã ã•ã„。"
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr "<literal>insert</literal> (オプション - デフォルト㯠<literal>true</literal> ): SQLã®insertæ–‡ã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ»ã‚«ãƒ©ãƒ ã‚’å«ã‚ã‚‹ã¹ãã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ ã‚‚ã—データベース・カラムã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ãŒ <literal>0</literal> ã¨å®šç¾©ã•ã‚Œã‚‹ã¨ãã«ã¯ã€ <literal>false</literal> ã«è¨å®šã™ã‚‹ã¨è‰¯ã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚„タイムスタンプã®ãƒ—ãƒãƒ‘ティã¯ã€åˆ†é›¢ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«å¯¾ã—ã¦nullã§ã‚ã£ã¦ã¯ãªã‚Šã¾ã›ã‚“。 ãã®ãŸã‚ã©ã®ã‚ˆã†ãª <literal>unsaved-value</literal> 戦略ãŒæŒ‡å®šã•ã‚Œã¦ã‚‚〠Hibernateã¯nullã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚„タイムスタンプをæŒã£ãŸã™ã¹ã¦ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’〠一時的ãªã‚‚ã®ã§ã‚ã‚‹ã¨åˆ¤æ–ã—ã¾ã™ã€‚ <emphasis> nullを許容ã™ã‚‹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚„タイムスタンプã®ãƒ—ãƒãƒ‘ティを定義ã™ã‚‹ã“ã¨ã¯ã€ éŽæ¸¡çš„ã«ä¸€æ™‚オブジェクトã¨ã™ã‚‹ã“ã¨ã‚’防ãç°¡å˜ãªæ–¹æ³•ã§ã™ã€‚ 特ã«è˜åˆ¥åã®å‰²ã‚Šå½“ã¦ã‚„複åˆã‚ーを使用ã—ã¦ã„ã‚‹ã¨ãã«ã¯ç‰¹ã«æœ‰ç”¨ã§ã™ã€‚</emphasis>"
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr "timestamp（オプション）"
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr "オプション㮠<literal><timestamp></literal> è¦ç´ ã¯ã€ テーブルãŒã‚¿ã‚¤ãƒ スタンプデータをå«ã‚€ã“ã¨ã‚’示ã—ã¾ã™ã€‚ ã“ã‚Œã¯ãƒãƒ¼ã‚¸ãƒ§ãƒ³ä»˜ã‘ã®ä»£ã‚ã‚Šã®æ–¹æ³•ã¨ã—ã¦ç”¨æ„ã•ã‚Œã¦ã„ã¾ã™ã€‚ タイムスタンプã¯ã‚‚ã¨ã‚‚ã¨æ¥½è¦³çš„ãƒãƒƒã‚¯ã«ãŠã‘る安全性ã®ä½Žã„実装ã§ã™ã€‚ ã—ã‹ã—アプリケーションã¯ç•°ãªã‚‹ç”¨é€”ã§ä½¿ã†ã“ã¨ã‚‚ã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr ""
+ "<![CDATA[<timestamp
+\n"
+ " column=\"timestamp_column\"
+\n"
+ " name=\"propertyName\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " unsaved-value=\"null|undefined\"
+\n"
+ " source=\"vm|db\"
+\n"
+ " generated=\"never|always\"
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ "/>]]>"
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr "<literal>column</literal>（オプション - デフォルトã¯ãƒ—ãƒãƒ‘ティå）： タイムスタンプをä¿æŒã™ã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã€‚"
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr "<literal>name</literal> ： 永続クラスã§ã‚ã‚‹Java ã® <literal>Date</literal>åž‹ ã¾ãŸã¯ <literal>Timestamp</literal> åž‹ ã®ã€JavaBeansスタイルプãƒãƒ‘ティã®åå‰ã€‚"
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr "<literal>access</literal> （オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr "<literal>unsaved-value</literal> （オプション - デフォルト㯠<literal>null</literal> ）： インスタンスãŒæ–°ã—ãインスタンス化ã•ã‚ŒãŸ （セーブã•ã‚Œã¦ã„ãªã„）ã“ã¨ã‚’示ã™ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティã®å€¤ã€‚ 以å‰ã®Sessionã§ã‚»ãƒ¼ãƒ–ã¾ãŸã¯ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸä¸€æ™‚çš„ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¨ 区別ã™ã‚‹ãŸã‚ã«ä½¿ã‚ã‚Œã¾ã™ã€‚ （ <literal>undefined</literal> ã¨æŒ‡å®šã™ã‚‹ã¨ã€ è˜åˆ¥åプãƒãƒ‘ティã®å€¤ãŒä½¿ã‚ã‚Œã¾ã™ã€‚）"
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr "<literal>source</literal> (オプション - デフォルト㯠<literal>vm</literal> ): Hibernateã¯ã©ã“ã‹ã‚‰ã‚¿ã‚¤ãƒ スタンプã®å€¤ã‚’å–å¾—ã™ã‚‹ã¹ãã§ã—ょã†ã‹ï¼Ÿ データベースã‹ã‚‰ã§ã—ょã†ã‹ã€ç¾åœ¨ã®JVMã‹ã‚‰ã§ã—ょã†ã‹ï¼Ÿ データベースã«ã‚ˆã‚‹ã‚¿ã‚¤ãƒ スタンプã¯ã€HibernateãŒ\"次ã®å€¤\"を決定ã™ã‚‹ãŸã‚㫠データベースをヒットã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ãŸã‚ã€ã‚ªãƒ¼ãƒãƒ˜ãƒƒãƒ‰ã‚’æ‹›ãã¾ã™ã€‚ ã—ã‹ã—クラスタ環境ã§ã¯JVMã‹ã‚‰å–å¾—ã™ã‚‹ã‚ˆã‚Šå®‰å…¨ã§ã™ã€‚ データベースã®ç¾åœ¨ã®ã‚¿ã‚¤ãƒ スタンプã®å–得をサãƒãƒ¼ãƒˆã™ã‚‹ ã™ã¹ã¦ã® <literal>データベース方言</literal> ãŒçŸ¥ã‚‰ã‚Œã¦ã„ã‚‹ã‚ã‘ã§ã¯ãªã„ã“ã¨ã« 注æ„ã—ã¦ãã ã•ã„。ã¾ãŸä¸€æ–¹ã§ã€ç²¾å¯†ã•ã‚’æ¬ ããŸã‚ã«ã€ ãƒãƒƒã‚¯ã§ä½¿ç”¨ã™ã‚‹ã«ã¯å®‰å…¨ã§ãªã„ã‚‚ã®ã‚‚ã‚ã‚Šã¾ã™(例ãˆã°Oracle 8)。"
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr "<literal>generated</literal> (オプション - デフォルト㯠<literal>never</literal> ): ã“ã®ã‚¿ã‚¤ãƒ スタンプ・プãƒãƒ‘ティã®å€¤ãŒã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚ˆã£ã¦ç”Ÿæˆã•ã‚Œã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚ <xref linkend=\"mapping-generated\"/>生æˆãƒ—ãƒãƒ‘ティ ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr "<literal><timestamp></literal> 㯠<literal><version type=\"timestamp\"></literal> ã¨ç‰ä¾¡ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 <literal><timestamp source=\"db\"></literal> 㯠<literal><version type=\"dbtimestamp\"></literal> ã¨ç‰ä¾¡ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "property"
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr "<literal><property></literal> è¦ç´ ã¯ã€ã‚¯ãƒ©ã‚¹ã®æ°¸ç¶šçš„ãªJavaBeanスタイルã®ãƒ—ãƒãƒ‘ティを定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr ""
+ "<![CDATA[<property
+\n"
+ " name=\"propertyName\"
+\n"
+ " column=\"column_name\"
+\n"
+ " type=\"typename\"
+\n"
+ " update=\"true|false\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " formula=\"arbitrary SQL expression\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " unique=\"true|false\"
+\n"
+ " not-null=\"true|false\"
+\n"
+ " optimistic-lock=\"true|false\"
+\n"
+ " generated=\"never|insert|always\"
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ " index=\"index_name\"
+\n"
+ " unique_key=\"unique_key_id\"
+\n"
+ " length=\"L\"
+\n"
+ " precision=\"P\"
+\n"
+ " scale=\"S\"
+\n"
+ "/>]]>"
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr "<literal>name</literal>：å°æ–‡å—ã§å§‹ã¾ã‚‹ãƒ—ãƒãƒ‘ティå。"
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr "<literal>column</literal>（オプション - デフォルトã¯ãƒ—ãƒãƒ‘ティå）： マッピングã•ã‚ŒãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルã®ã‚«ãƒ©ãƒ ã®åå‰ã€‚ ãƒã‚¹ãƒˆã—㟠<literal><column></literal> è¦ç´ ã§ã‚‚指定ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "<literal>type</literal>（オプション）：Hibernateã®åž‹ã‚’示ã™åå‰ã€‚"
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr "<literal>update, insert</literal> （オプション - デフォルト㯠<literal>true</literal> ）： マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQLã® <literal>UPDATE</literal> ã‚„ <literal>INSERT</literal> ã«å«ã¾ã‚Œã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚ 両方ã¨ã‚‚ <literal>false</literal> ã«è¨å®šã™ã‚‹ã¨ã€ åŒã˜ã‚«ãƒ©ãƒ ã«ãƒžãƒƒãƒ”ングã•ã‚ŒãŸä»–ã®ãƒ—ãƒãƒ‘ティやトリガや ä»–ã®ã‚¢ãƒ—リケーションã«ã‚ˆã£ã¦åˆæœŸåŒ–ã•ã‚ŒãŸç´”粋ãªã€Œå°Žå‡ºã€ãƒ—ãƒãƒ‘ティãŒå¯èƒ½ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr "<literal>formula</literal>（オプション）： <emphasis>計算</emphasis> プãƒãƒ‘ティã®ãŸã‚ã®å€¤ã‚’定義ã™ã‚‹SQLå¼ã€‚ 計算ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã¯è‡ªèº«ã®ã‚«ãƒ©ãƒ ã¸ã®ãƒžãƒƒãƒ”ングãŒã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr "<literal>access</literal>（オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "<literal>unique</literal> (オプション):カラムã«ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ã‚’ã¤ã‘ã‚‹DDLã®ç”Ÿæˆã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚ ã¾ãŸã€<literal>property-ref</literal> ã®ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã¨ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>not-null</literal> (オプション):カラムã«null値を許å¯ã™ã‚‹DDLã®ç”Ÿæˆã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr "<literal>optimistic-lock</literal> (オプション - デフォルト㯠<literal>true</literal> ): ã“ã®ãƒ—ãƒãƒ‘ティã®æ›´æ–°ã«æ¥½è¦³ãƒãƒƒã‚¯ã®å–å¾—ã‚’è¦æ±‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ã“ã®ãƒ—ãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹ã¨ãã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’増やã™ã¹ãã‹ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "<literal>generated</literal> (オプション - デフォルト㯠<literal>never</literal> ): プãƒãƒ‘ティã®å€¤ãŒã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚ˆã£ã¦ç”Ÿæˆã•ã‚ŒãŸã“ã¨ã‚’指定ã—ã¾ã™ã€‚ <xref linkend=\"mapping-generated\"/>生æˆãƒ—ãƒãƒ‘ティ ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr "<emphasis>typename</emphasis> ã«ã¯ä»¥ä¸‹ã®å€¤ãŒå¯èƒ½ã§ã™ï¼š"
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr "Hibernateã®åŸºæœ¬åž‹ã®åå‰ï¼ˆä¾‹ <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal> ）。"
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr "デフォルトã®åŸºæœ¬åž‹ã®Javaクラスå （例 <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal> ）。"
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "シリアライズå¯èƒ½ãªJavaクラスã®åå‰ã€‚"
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr "カスタム型ã®ã‚¯ãƒ©ã‚¹å（例 <literal>com.illflow.type.MyCustomType</literal> ）。"
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "型を指定ã—ãªã‘ã‚Œã°ã€Hibernateã¯æ£ã—ã„Hibernateã®åž‹ã‚’推測ã™ã‚‹ãŸã‚ã«ã€ 指定ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã«å¯¾ã—ã¦ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã„ã¾ã™ã€‚ Hibernateã¯ãƒ«ãƒ¼ãƒ«2, 3, 4ã‚’ãã®é †åºã«ä½¿ã„〠getterプãƒãƒ‘ティã®è¿”り値ã®ã‚¯ãƒ©ã‚¹ã®åå‰ã‚’解釈ã—よã†ã¨ã—ã¾ã™ã€‚ ã—ã‹ã—ã“ã‚Œã§å¸¸ã«å分ã§ã‚ã‚‹ã¨ã¯é™ã‚Šã¾ã›ã‚“。 å ´åˆã«ã‚ˆã£ã¦ã¯ã€<literal>type</literal> 属性ãŒå¿…è¦ãªå ´åˆãŒã‚ã‚Šã¾ã™ã€‚ （例ãˆã° <literal>Hibernate.DATE</literal> 㨠<literal>Hibernate.TIMESTAMP</literal> を区別ã™ã‚‹ãŸã‚〠ã¾ãŸã¯ã‚«ã‚¹ã‚¿ãƒ 型を指定ã™ã‚‹ãŸã‚ãªã©ã§ã™ã€‚）"
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "特ã«å¼·åŠ›ãªç‰¹å¾´ã¯ç”Ÿæˆãƒ—ãƒãƒ‘ティã§ã™ã€‚ ã“れらã®ãƒ—ãƒãƒ‘ティã¯å½“然èªã¿å–り専用ã§ã‚ã‚Šã€ãƒ—ãƒãƒ‘ティã®å€¤ã¯ãƒãƒ¼ãƒ‰æ™‚ã«è¨ˆç®—ã•ã‚Œã¾ã™ã€‚ 計算をSQLå¼ã¨ã—ã¦å®£è¨€ã™ã‚‹ã¨ã€ã“ã®ãƒ—ãƒãƒ‘ティ㯠インスタンスをãƒãƒ¼ãƒ‰ã™ã‚‹SQLクエリ㮠<literal>SELECT</literal> å¥ã®ã‚µãƒ–クエリã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr ""
+ "<![CDATA[
+\n"
+ "<property name=\"totalPrice\"
+\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p
+\n"
+ " WHERE li.productId = p.productId
+\n"
+ " AND li.customerId = customerId
+\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "特定ã®ã‚«ãƒ©ãƒ (例ã§ã¯ <literal>customerId</literal> ãŒãã‚Œã«ã‚ãŸã‚Šã¾ã™)ã®ã‚¨ã‚¤ãƒªã‚¢ã‚¹ã‚’宣言ã™ã‚‹ã“ã¨ãªã〠エンティティ自身ã®ãƒ†ãƒ¼ãƒ–ルをå‚ç…§ã§ãã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã‚‚ã—属性を使用ã—ãŸããªã‘ã‚Œã°ã€ ãƒã‚¹ãƒˆã—㟠<literal><formula></literal> マッピングè¦ç´ を使ãˆã‚‹ã“ã¨ã«ã‚‚注æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr "many-to-one"
+
+#: index.docbook:1284
+msgid "property"
+msgstr "ä»–ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã¸ã®é€šå¸¸ã®é–¢é€£ã¯ <literal>many-to-one</literal> è¦ç´ を使ã£ã¦å®šç¾©ã—ã¾ã™ã€‚ リレーショナルモデルã¯å¤šå¯¾ä¸€é–¢é€£ã§ã™ã€‚ ã¤ã¾ã‚Šã‚るテーブルã®å¤–部ã‚ーã¯ã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã¨ãªã‚‹ãƒ†ãƒ¼ãƒ–ルã®ä¸»ã‚ーカラムをå‚ç…§ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr ""
+ "<![CDATA[<many-to-one
+\n"
+ " name=\"propertyName\"
+\n"
+ " column=\"column_name\"
+\n"
+ " class=\"ClassName\"
+\n"
+ " cascade=\"cascade_style\"
+\n"
+ " fetch=\"join|select\"
+\n"
+ " update=\"true|false\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " unique=\"true|false\"
+\n"
+ " not-null=\"true|false\"
+\n"
+ " optimistic-lock=\"true|false\"
+\n"
+ " lazy=\"proxy|no-proxy|false\"
+\n"
+ " not-found=\"ignore|exception\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " formula=\"arbitrary SQL expression\"
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ " embed-xml=\"true|false\"
+\n"
+ " index=\"index_name\"
+\n"
+ " unique_key=\"unique_key_id\"
+\n"
+ " foreign-key=\"foreign_key_name\"
+\n"
+ "/>]]>"
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr "<literal>name</literal>：プãƒãƒ‘ティå。"
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr "<literal>column</literal> (オプション):外部ã‚ーカラムã®åå‰ã€‚ ãƒã‚¹ãƒˆã—㟠<literal><column></literal> è¦ç´ ã§ã‚‚指定ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>class</literal>（オプション - デフォルトã¯ã€ リフレクションã«ã‚ˆã‚Šæ±ºå®šã•ã‚Œã‚‹ãƒ—ãƒãƒ‘ティã®åž‹ï¼‰ï¼šé–¢é€£ã‚¯ãƒ©ã‚¹ã®åå‰ã€‚"
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr "<literal>cascade</literal>（オプション）： ã©ã®æ“作をã€è¦ªã‚ªãƒ–ジェクトã‹ã‚‰é–¢é€£ã‚ªãƒ–ジェクトã¸ã¨ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã•ã›ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "<literal>fetch</literal> (オプション - デフォルト㯠<literal>select</literal> ): 外部çµåˆãƒ•ã‚§ãƒƒãƒã‹é †æ¬¡é¸æŠžãƒ•ã‚§ãƒƒãƒï¼ˆsequential select fetch）をé¸æŠžã—ã¾ã™ã€‚"
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "<literal>update, insert</literal>（オプション - デフォルト㯠<literal>true</literal> ）： マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQLã® <literal>UPDATE</literal> ã¾ãŸã¯ <literal>INSERT</literal> æ–‡ã«å«ã¾ã‚Œã‚‹ã“ã¨ã‚’指定ã—ã¾ã™ã€‚ 両方ã¨ã‚‚ <literal>false</literal> ã«è¨å®šã™ã‚‹ã¨ã€ ãã®å€¤ãŒåŒã˜ã‚«ãƒ©ãƒ ã«ãƒžãƒƒãƒ”ングã•ã‚ŒãŸä»–ã®ãƒ—ãƒãƒ‘ティやトリガや ä»–ã®ã‚¢ãƒ—リケーションã«ã‚ˆã£ã¦åˆæœŸåŒ–ã•ã‚ŒãŸç´”粋ãªã€Œå°Žå‡ºã€ãƒ—ãƒãƒ‘ティãŒå¯èƒ½ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>access</literal>（オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>unique</literal>（オプション）： 外部ã‚ーカラムã«å¯¾ã—ã¦ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ã‚’ã¤ã‘ãŸDDLã®ç”Ÿæˆã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚ ã¾ãŸã€<literal>property-ref</literal> ã®ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã«ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚Šé–¢é€£ã®å¤šé‡åº¦ã‚’効果的ã«ä¸€å¯¾ä¸€ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr "<literal>not-null</literal> (オプション):外部ã‚ーカラムã«å¯¾ã—ã¦ã€ null値を許å¯ã™ã‚‹DDLã®ç”Ÿæˆã‚’å¯èƒ½ã«ã—ã¾ã™"
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "<literal>optimistic-lock</literal> (オプション - デフォルト㯠<literal>true</literal> ): ã“ã®ãƒ—ãƒãƒ‘ティã®æ›´æ–°ã«æ¥½è¦³çš„ãƒãƒƒã‚¯ã®å–å¾—ã‚’è¦æ±‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ã“ã®ãƒ—ãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹ã¨ãã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’増やã™ã¹ãã‹ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>lazy</literal> (オプション - デフォルト㯠<literal>proxy</literal> ): デフォルトã§ã¯ã€å¤šé‡åº¦ï¼‘ã®é–¢é€£ãŒãƒ—ãƒã‚ã‚·ã¨ãªã‚Šã¾ã™ã€‚ <literal>lazy=\"no-proxy\"</literal> ã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ã«æœ€åˆã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã¨ãã«ã€ プãƒãƒ‘ティをé…延フェッãƒã™ã‚‹ã‚ˆã†æŒ‡å®šã—ã¾ã™ (ビルド時ã«ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰å®Ÿè£…ãŒå¿…è¦ã«ãªã‚Šã¾ã™)。 <literal>lazy=\"false\"</literal> ã¯é–¢é€£ã‚’常ã«å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã‚ˆã†æŒ‡å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr "<literal>not-found</literal> (オプション - デフォルト㯠<literal>exception</literal> ): æ¬ è½ã—ãŸè¡Œã‚’å‚ç…§ã™ã‚‹å¤–部ã‚ーをã©ã®ã‚ˆã†ã«æ‰±ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ <literal>ignore</literal> ã¯æ¬ è½ã—ãŸè¡Œã‚’null関連ã¨ã—ã¦æ‰±ã„ã¾ã™ã€‚"
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr "<literal>entity-name</literal> (オプション):関連ã—ãŸã‚¯ãƒ©ã‚¹ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å。"
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr "<literal>formula</literal> (オプション): <emphasis> 計算ã•ã‚ŒãŸ</emphasis> 外部ã‚ーã«å¯¾ã—ã¦å€¤ã‚’定義ã™ã‚‹SQLå¼"
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr "<literal>cascade</literal> 属性㫠<literal>none</literal> 以外ã®æ„味ã®ã‚る値ををè¨å®šã™ã‚‹ã¨ã€ 関連オブジェクトã¸ã‚ã‚‹æ“作ãŒä¼æ’ã™ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ æ„味ã®ã‚る値ã¨ã¯Hibernateã®åŸºæœ¬æ“作ã®åå‰ã®ã“ã¨ã§ã€ <literal>delete-orphan</literal> 㨠<literal>all</literal> ã€æ“作åをカンマã§åŒºåˆ‡ã£ãŸçµ„ã¿åˆã‚㛠（例ãˆã° <literal>cascade=\"persist,merge,evict\"</literal> ã‚„ <literal>cascade=\"all,delete-orphan\"</literal>）〠ã¾ãŸãã‚Œã ã‘ã§ãªã <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal> ã®ã“ã¨ã‚’指ã—ã¾ã™ã€‚ 詳ã—ã„説明㯠<xref linkend=\"objectstate-transitive\"/> を見ã¦ãã ã•ã„。 値ãŒä¸€ã¤ã®é–¢é€£(many-to-oneã¨one-to-one関連)ã¯ã€ å˜ç‹¬ã§ã®å‰Šé™¤ï¼ˆorphan delete)をサãƒãƒ¼ãƒˆã—ã¦ã„ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr "典型的㪠<literal>many-to-one</literal> 宣言ã¯æ¬¡ã®ã‚ˆã†ã«ã‚·ãƒ³ãƒ—ルã§ã™ã€‚："
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "<literal>property-ref</literal> 属性ã¯ã€å¤–部ã‚ーãŒé–¢é€£ä»˜ã‘られãŸãƒ†ãƒ¼ãƒ–ルã®ã€ä¸»ã‚ーã§ãªã„ ユニークã‚ーをå‚ç…§ã—ã¦ã„るレガシーデータをマップã™ã‚‹ãŸã‚ã«ã ã‘使ã†ã¹ãã§ã™ã€‚ ã“ã‚Œã¯é†œã„リレーショナルモデルã§ã™ã€‚ 例ãˆã° <literal>Product</literal> クラスãŒã€ 主ã‚ーã§ãªã„ユニークãªã‚·ãƒªã‚¢ãƒ«ãƒŠãƒ³ãƒãƒ¼ã‚’æŒã£ã¦ã„ã‚‹ã¨ä»®å®šã—ã¦ã¿ã¦ãã ã•ã„。 （ <literal>unique</literal> 属性ã¯SchemaExportツールを使ã£ãŸHibernateã®DDL生æˆã‚’制御ã—ã¾ã™ã€‚）"
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr "以下ã®ã‚ˆã†ã« <literal>OrderItem</literal> ã«å¯¾ã—ã¦ãƒžãƒƒãƒ”ングを使ãˆã¾ã™ï¼š"
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr "ã—ã‹ã—ã€ã“ã‚Œã¯æ±ºã—ã¦æŽ¨å¥¨ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "å‚ç…§ã—ãŸãƒ¦ãƒ‹ãƒ¼ã‚¯ã‚ーãŒã€é–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å¤šæ•°ã®ãƒ—ãƒãƒ‘ティã‹ã‚‰æ§‹æˆã•ã‚Œã‚‹å ´åˆã€ 指定ã—㟠<literal><properties></literal> è¦ç´ 内ã§ã€å‚ç…§ã™ã‚‹ãƒ—ãƒãƒ‘ティをマッピングã™ã‚‹ã¹ãã§ã™ã€‚"
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "ã‚‚ã—å‚ç…§ã—ãŸãƒ¦ãƒ‹ãƒ¼ã‚¯ã‚ーãŒã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã®ãƒ—ãƒãƒ‘ティã§ã‚ã‚‹å ´åˆã¯ã€ãƒ—ãƒãƒ‘ティã®ãƒ‘スを指定ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "one-to-one"
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr "ä»–ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã¸ã®ä¸€å¯¾ä¸€é–¢é€£ã¯ã€<literal>one-to-one</literal> è¦ç´ ã§å®šç¾©ã—ã¾ã™ã€‚"
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+ "<![CDATA[<one-to-one
+\n"
+ " name=\"propertyName\"
+\n"
+ " class=\"ClassName\"
+\n"
+ " cascade=\"cascade_style\"
+\n"
+ " constrained=\"true|false\"
+\n"
+ " fetch=\"join|select\"
+\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " formula=\"any SQL expression\"
+\n"
+ " lazy=\"proxy|no-proxy|false\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"
+\n"
+ " embed-xml=\"true|false\"
+\n"
+ " foreign-key=\"foreign_key_name\"
+\n"
+ "/>]]>"
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr "<literal>name</literal>：プãƒãƒ‘ティå。"
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "<literal>class</literal>（オプション - デフォルトã¯ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã‚ˆã‚Šæ±ºå®šã•ã‚Œã‚‹ãƒ—ãƒãƒ‘ティã®åž‹ï¼‰ï¼š 関連クラスã®åå‰ã€‚"
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr "<literal>cascade</literal>（オプション）： 親オブジェクトã‹ã‚‰é–¢é€£ã‚ªãƒ–ジェクトã¸ã€ã©ã®æ“作をカスケードã™ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr "<literal>fetch</literal>（オプション - デフォルト㯠<literal>select</literal> ）： 外部çµåˆãƒ•ã‚§ãƒƒãƒã¨é †æ¬¡é¸æŠžãƒ•ã‚§ãƒƒãƒï¼ˆsequential select fetch）ã®ã©ã¡ã‚‰ã‹ã‚’é¸æŠžã—ã¾ã™ã€‚"
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr "<literal>property-ref</literal>（オプション）： ã“ã®ã‚¯ãƒ©ã‚¹ã®ä¸»ã‚ーã«çµåˆã•ã‚ŒãŸé–¢é€£ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティå。 指定ã•ã‚Œãªã‘ã‚Œã°ã€é–¢é€£ã‚¯ãƒ©ã‚¹ã®ä¸»ã‚ーãŒä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr "<literal>access</literal>（オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "<literal>formula</literal> (オプション): ã»ã¨ã‚“ã©ã™ã¹ã¦ã®ä¸€å¯¾ä¸€é–¢é€£ã¯ã‚ªãƒ¼ãƒŠãƒ¼ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ä¸»ã‚ーã¸ã¨ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚ ã“れ以外ã®ç¨€ãªå ´åˆã¯ã€ ä»–ã®ã‚«ãƒ©ãƒ ã‚„ã€è¤‡æ•°ã®ã‚«ãƒ©ãƒ ã€SQL構文を使ã£ãŸçµåˆã™ã‚‹ãŸã‚ã®å¼ã‚’指定ã§ãã¾ã™ã€‚ （例㯠<literal>org.hibernate.test.onetooneformula</literal> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。）"
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>lazy</literal> (オプション - デフォルト㯠<literal>proxy</literal> ): デフォルトã§ã¯ã€å¤šé‡åº¦ï¼‘ã®é–¢é€£ãŒãƒ—ãƒã‚ã‚·ã¨ãªã‚Šã¾ã™ã€‚ <literal>lazy=\"no-proxy\"</literal> ã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ã«æœ€åˆã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã¨ãã«ã€ プãƒãƒ‘ティをé…延フェッãƒã™ã‚‹ã‚ˆã†æŒ‡å®šã—ã¾ã™ (ビルド時ã«ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰å®Ÿè£…ãŒå¿…è¦ã«ãªã‚Šã¾ã™)。 <literal>lazy=\"false\"</literal> ã¯é–¢é€£ã‚’常ã«å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã‚ˆã†æŒ‡å®šã—ã¾ã™ã€‚ <emphasis>ã‚‚ã— <literal>constrained=\"false\"</literal> ãªã‚‰ã°ã€ プãƒã‚ã‚·ã¯ä½¿ç”¨ä¸å¯èƒ½ã¨ãªã‚Šã€é–¢é€£ã‚’å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„ï¼</emphasis>"
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr "<literal>entity-name</literal> (オプション):関連クラスã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å"
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr "一対一関連ã«ã¯2種類ã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr "主ã‚ー関連"
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr "ユニーク外部ã‚ー関連"
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr "主ã‚ー関連ã«ã¯ã€ç‰¹åˆ¥ãªãƒ†ãƒ¼ãƒ–ルカラムã¯å¿…è¦ã‚ã‚Šã¾ã›ã‚“。 ã‚‚ã—2ã¤ã®è¡ŒãŒé–¢é€£ã«ã‚ˆã‚Šé–¢ä¿‚ã—ã¦ã„ã‚Œã°ã€2ã¤ã®ãƒ†ãƒ¼ãƒ–ルã¯åŒã˜ä¸»ã‚ーã®å€¤ã‚’共有ã—ã¾ã™ã€‚ ãã®ãŸã‚2ã¤ã®ã‚ªãƒ–ジェクトを主ã‚ー関連ã«ã‚ˆã£ã¦é–¢é€£ä»˜ã‘ãŸã„ã®ã§ã‚ã‚Œã°ã€ 確実ã«åŒã˜è˜åˆ¥åã®å€¤ã‚’代入ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr "主ã‚ー関連を行ã†ãŸã‚ã«ã¯ã€ä»¥ä¸‹ã®ãƒžãƒƒãƒ”ングを <literal>Employee</literal> 㨠<literal>Person</literal> ã®ãã‚Œãžã‚Œã«è¿½åŠ ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr "ã“ã“ã§ã€PERSONã¨EMPLOYEEテーブルã®é–¢ä¿‚ã™ã‚‹è¡Œã®ä¸»ã‚ーãŒåŒã˜ã§ã‚ã‚‹ã“ã¨ã‚’確実ã«ã—ãªã‘ã‚Œã°ã„ã‘ã¾ã›ã‚“。 ã“ã“ã§ã¯ã€<literal>foreign</literal> ã¨ã„ã†ç‰¹æ®ŠãªHibernateè˜åˆ¥å生æˆæˆ¦ç•¥ã‚’使ã„ã¾ã™ï¼š"
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">
+\n"
+ " <id name=\"id\" column=\"PERSON_ID\">
+\n"
+ " <generator class=\"foreign\">
+\n"
+ " <param name=\"property\">employee</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " ...
+\n"
+ " <one-to-one name=\"employee\"
+\n"
+ " class=\"Employee\"
+\n"
+ " constrained=\"true\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr "<literal>Employee</literal> インスタンスãŒã€<literal>Person</literal> ã® <literal>employee</literal> プãƒãƒ‘ティã§å‚ç…§ã•ã‚Œã‚‹ã‚ˆã†ã«ã€ æ–°ã—ãセーブã•ã‚ŒãŸ <literal>Person</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«ã¯åŒã˜ä¸»ã‚ーã®å€¤ãŒä»£å…¥ã•ã‚Œã¾ã™ã€‚ æ–°ã—ãセーブã™ã‚‹ <literal>Person</literal> インスタンスã¯ã€ ãã® <literal>Person</literal> ã® <literal>employee</literal> プãƒãƒ‘ティãŒå‚ç…§ã™ã‚‹ <literal>Employee</literal> インスタンスã¨ã—ã¦åŒã˜ä¸»ã‚ーãŒå‰²ã‚Šå½“ã¦ã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr "ã‚‚ã†1ã¤ã®æ–¹æ³•ã¨ã—ã¦ã€<literal>Employee</literal> ã‹ã‚‰ <literal>Person</literal> ã¸ã® ユニーク制約を使ã£ãŸå¤–部ã‚ー関連ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«è¡¨ç¾ã•ã‚Œã¾ã™ï¼š"
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr "ãã—ã¦ã“ã®é–¢é€£ã¯ã€ 以下ã®è¨˜è¿°ã‚’ <literal>Person</literal> ã®ãƒžãƒƒãƒ”ングã«è¿½åŠ ã™ã‚‹ã“ã¨ã§åŒæ–¹å‘ã«ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ï¼š"
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "natural-id"
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "エンティティã®è‡ªç„¶ã‚ープãƒãƒ‘ティã®æ¯”較ã«ã¯ã€ <literal>equals()</literal> 㨠<literal>hashCode()</literal> ã®å®Ÿè£…ã‚’å¼·ããŠå‹§ã‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr "ã“ã®ãƒžãƒƒãƒ”ングã¯è‡ªç„¶ä¸»ã‚ーを使ã£ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã§ã®ä½¿ç”¨ã‚’æ„図ã—ã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr "component, dynamic-component"
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr ""
+ "<![CDATA[<component
+\n"
+ " name=\"propertyName\"
+\n"
+ " class=\"className\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " update=\"true|false\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " optimistic-lock=\"true|false\"
+\n"
+ " unique=\"true|false\"
+\n"
+ " node=\"element-name|.\"
+\n"
+ ">
+\n"
+ "
+\n"
+ " <property ...../>
+\n"
+ " <many-to-one .... />
+\n"
+ " ........
+\n"
+ "</component>]]>"
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr "<literal>name</literal>：プãƒãƒ‘ティå。"
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr "<literal>insert</literal> ：マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQLã® <literal>INSERT</literal> ã«ç¾ã‚Œã‚‹ã‚ˆã†ã«ã™ã‚‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr "<literal>update</literal> : マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQL ã® <literal>UPDATE</literal> ã«ç¾ã‚Œã‚‹ã‚ˆã†ã«ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr "<literal>access</literal> （オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr "<literal>lazy</literal> (optional - デフォルト㯠<literal>false</literal> ): インスタンス変数ã«æœ€åˆã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã¨ãã«ã€ コンãƒãƒ¼ãƒãƒ³ãƒˆã‚’é…延ã—ã¦ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã‚ˆã†æŒ‡å®šã—ã¾ã™ã€‚ (ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰å®Ÿè£…を作æˆã™ã‚‹æ™‚é–“ãŒå¿…è¦ã«ãªã‚Šã¾ã™)"
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr "<literal>optimistic-lock</literal> (オプション - デフォルト㯠<literal>true</literal> ): ã“ã®ãƒ—ãƒãƒ‘ティã®æ›´æ–°ã«ã€æ¥½è¦³ãƒãƒƒã‚¯ã®å–å¾—ã‚’è¦æ±‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ã“ã®ãƒ—ãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹ã¨ãã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’増やã™ã¹ãã‹ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr "<literal>unique</literal> (オプション - デフォルト㯠<literal>false</literal> ): コンãƒãƒ¼ãƒãƒ³ãƒˆã®ã™ã¹ã¦ã®ãƒžãƒƒãƒ”ングã™ã‚‹ã‚«ãƒ©ãƒ ã«ã€ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ãŒå˜åœ¨ã™ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr "åã® <literal><property></literal> ã‚¿ã‚°ã§ã€ åã®ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティをテーブルカラムã«ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚"
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "<literal><component></literal> è¦ç´ ã¯ã€è¦ªã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸æˆ»ã‚‹å‚ç…§ã¨ã—ã¦ã€ コンãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティをマッピングã™ã‚‹ <literal><parent></literal> サブè¦ç´ を許å¯ã—ã¾ã™ã€‚"
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr "<literal><dynamic-component></literal> è¦ç´ ã¯ã€ <literal>Map</literal> ãŒã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¨ã—ã¦ãƒžãƒƒãƒ”ングã•ã‚Œã‚‹ã“ã¨ã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚ プãƒãƒ‘ティåã¯mapã®ã‚ーをå‚ç…§ã—ã¾ã™ã€‚<xref linkend=\"components-dynamic\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "properties"
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr "<literal><properties></literal> è¦ç´ ã¯ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティã®æŒ‡å®šã•ã‚ŒãŸã€ è«–ç†çš„ãªã‚°ãƒ«ãƒ¼ãƒ”ングをå¯èƒ½ã«ã—ã¾ã™ã€‚ ã“ã®æ§‹é€ ã®æœ€ã‚‚é‡è¦ãªä½¿ç”¨æ–¹æ³•ã¯ã€ <literal>property-ref</literal> ã®ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã«ãªã‚‹ãƒ—ãƒãƒ‘ティã®çµåˆã‚’許å¯ã™ã‚‹ã“ã¨ã§ã™ã€‚ ãã‚Œã¯ã¾ãŸã€è¤‡æ•°ã‚«ãƒ©ãƒ ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„を定義ã™ã‚‹ç°¡å˜ãªæ–¹æ³•ã§ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr ""
+ "<![CDATA[<properties
+\n"
+ " name=\"logicalName\"
+\n"
+ " insert=\"true|false\"
+\n"
+ " update=\"true|false\"
+\n"
+ " optimistic-lock=\"true|false\"
+\n"
+ " unique=\"true|false\"
+\n"
+ ">
+\n"
+ "
+\n"
+ " <property ...../>
+\n"
+ " <many-to-one .... />
+\n"
+ " ........
+\n"
+ "</properties>]]>"
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr "<literal>name</literal> : グルーピングã®è«–ç†å。 実際ã®ãƒ—ãƒãƒ‘ティåã§ã¯ <emphasis>ã‚ã‚Šã¾ã›ã‚“</emphasis> 。"
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr "<literal>insert</literal>：マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQLã® <literal>INSERT</literal> ã«ç¾ã‚Œã‚‹ã‚ˆã†ã«ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr "<literal>update</literal>：マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ãŒSQLã® <literal>UPDATE</literal> ã«ç¾ã‚Œã‚‹ã‚ˆã†ã«ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr "<literal>optimistic-lock</literal> (オプション - デフォルト㯠<literal>true</literal> ): ã“れらã®ãƒ—ãƒãƒ‘ティã®æ›´æ–°ã«æ¥½è¦³çš„ãƒãƒƒã‚¯ã®å–å¾—ã‚’è¦æ±‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ã“ã®ãƒ—ãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹ã¨ãã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’増やã™ã¹ãã‹ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr "<literal>unique</literal> (オプション - デフォルト㯠<literal>false</literal> ): コンãƒãƒ¼ãƒãƒ³ãƒˆã®ã™ã¹ã¦ã®ãƒžãƒƒãƒ”ングã™ã‚‹ã‚«ãƒ©ãƒ ã«ã€ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ãŒå˜åœ¨ã™ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "例ãˆã°ã€ã‚‚ã—以下ã®ã‚ˆã†ãª <literal><properties></literal> マッピングãŒã‚ã£ãŸå ´åˆï¼š"
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"personNumber\"/>
+\n"
+ " ...
+\n"
+ " <properties name=\"name\"
+\n"
+ " unique=\"true\" update=\"false\">
+\n"
+ " <property name=\"firstName\"/>
+\n"
+ " <property name=\"initial\"/>
+\n"
+ " <property name=\"lastName\"/>
+\n"
+ " </properties>
+\n"
+ "</class>]]>"
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr "主ã‚ーã®ä»£ã‚ã‚Šã« <literal>Person</literal> テーブルã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ã‚ーã¸ã®å‚照をæŒã¤ã€ レガシーデータã®é–¢é€£ã‚’æŒã¤ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。："
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"person\"
+\n"
+ " class=\"Person\" property-ref=\"name\">
+\n"
+ " <column name=\"firstName\"/>
+\n"
+ " <column name=\"initial\"/>
+\n"
+ " <column name=\"lastName\"/>
+\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr "ã—ã‹ã—ã€ã“ã®ã‚ˆã†ãªãƒ¬ã‚¬ã‚·ãƒ¼ãƒ‡ãƒ¼ã‚¿ãƒžãƒƒãƒ”ングã®ã‚³ãƒ³ãƒ†ã‚スト外ã¸ã®ä½¿ç”¨ã¯æŽ¨å¥¨ã—ã¾ã›ã‚“。"
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr "subclass"
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr ""
+ "<![CDATA[<subclass
+\n"
+ " name=\"ClassName\"
+\n"
+ " discriminator-value=\"discriminator_value\"
+\n"
+ " proxy=\"ProxyInterface\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " dynamic-update=\"true|false\"
+\n"
+ " dynamic-insert=\"true|false\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " node=\"element-name\"
+\n"
+ " extends=\"SuperclassName\">
+\n"
+ "
+\n"
+ " <property .... />
+\n"
+ " .....
+\n"
+ "</subclass>]]>"
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr "<literal>name</literal>：サブクラスã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸã‚¯ãƒ©ã‚¹å。"
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr "<literal>discriminator-value</literal>（オプション - デフォルトã¯ã‚¯ãƒ©ã‚¹å）： 個々ã®ã‚µãƒ–クラスを区別ã™ã‚‹ãŸã‚ã®å€¤ã€‚"
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>lazy</literal>（オプション, デフォルト㯠<literal>true</literal> ）： <literal>lazy=\"false\"</literal> ã¨è¨å®šã™ã‚‹ã¨ã€é…延フェッãƒãŒä½¿ç”¨ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "å„サブクラスã§ã¯ã€æ°¸ç¶šãƒ—ãƒãƒ‘ティã¨ã‚µãƒ–クラスを定義ã—ã¾ã™ã€‚ <literal><version></literal> 㨠<literal><id></literal> プãƒãƒ‘ティã¯ã€ ルートクラスã‹ã‚‰ç¶™æ‰¿ã•ã‚Œã‚‹ã¨ä»®å®šã•ã‚Œã¾ã™ã€‚ éšŽå±¤æ§‹é€ ã«ãŠã‘るサブクラスã¯ã€ ユニーク㪠<literal>discriminator-value</literal> を定義ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 noneãŒæŒ‡å®šã•ã‚Œã‚‹ã¨ã€å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸJavaクラスåãŒä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "継承ã®ãƒžãƒƒãƒ”ングã«é–¢ã™ã‚‹æƒ…å ±ã¯ <xref linkend=\"inheritance\"/> を見ã¦ãã ã•ã„。"
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr "joined-subclass"
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "ã‚‚ã†1ã¤ã®æ–¹æ³•ã¨ã—ã¦ã€å„サブクラスを自身ã®ãƒ†ãƒ¼ãƒ–ルã¸ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ (table-per-subclass mapping strategy)。 継承ã—ãŸçŠ¶æ…‹ã¯ã‚¹ãƒ¼ãƒ‘ークラスã®ãƒ†ãƒ¼ãƒ–ルを使ã£ãŸçµåˆã§æ¤œç´¢ã—ã¾ã™ã€‚ <literal><joined-subclass></literal> è¦ç´ を使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr ""
+ "<![CDATA[<joined-subclass
+\n"
+ " name=\"ClassName\"
+\n"
+ " table=\"tablename\"
+\n"
+ " proxy=\"ProxyInterface\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " dynamic-update=\"true|false\"
+\n"
+ " dynamic-insert=\"true|false\"
+\n"
+ " schema=\"schema\"
+\n"
+ " catalog=\"catalog\"
+\n"
+ " extends=\"SuperclassName\"
+\n"
+ " persister=\"ClassName\"
+\n"
+ " subselect=\"SQL expression\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " node=\"element-name\">
+\n"
+ "
+\n"
+ " <key .... >
+\n"
+ "
+\n"
+ " <property .... />
+\n"
+ " .....
+\n"
+ "</joined-subclass>]]>"
+
+#: index.docbook:1928
+msgid "properties"
+msgstr "<literal>name</literal>：サブクラスã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸã‚¯ãƒ©ã‚¹å。"
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr "<literal>table</literal> :サブクラステーブルã®åå‰ã€‚"
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr "<literal>proxy</literal> (オプション): é…延åˆæœŸåŒ–プãƒã‚ã‚·ã«ä½¿ç”¨ã™ã‚‹ã‚¯ãƒ©ã‚¹ã‚„インターフェイスを指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr "<literal>lazy</literal> (オプション, デフォルト㯠<literal>true</literal> ): <literal>lazy=\"false\"</literal> ã¨ã™ã‚‹ã¨ã€é…延フェッãƒãŒä½¿ç”¨ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr "継承ã®ãƒžãƒƒãƒ”ングã«é–¢ã™ã‚‹æƒ…å ±ã¯ <xref linkend=\"inheritance\"/> を見ã¦ãã ã•ã„。"
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr "3ã¤ç›®ã®é¸æŠžè‚¢ã¯ã€ç¶™æ‰¿éšŽå±¤ã®å…·è±¡ã‚¯ãƒ©ã‚¹ã®ã¿ã‚’テーブルã«ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ã§ã™ (the table-per-concrete-class戦略)。 ãã‚Œãžã‚Œã®ãƒ†ãƒ¼ãƒ–ルã¯ç¶™æ‰¿ã®çŠ¶æ…‹ã‚’å«ã‚ã™ã¹ã¦ã®ã‚¯ãƒ©ã‚¹ã®æ°¸ç¶šçŠ¶æ…‹ã‚’定義ã—ã¾ã™ã€‚ Hibernateã§ã¯ãã®æ§˜ãªç¶™æ‰¿éšŽå±¤ãŒå¿…ãšã—ã‚‚å¿…è¦ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 å˜ç´”ã«ãã‚Œãžã‚Œã®ã‚¯ãƒ©ã‚¹ã‚’〠別々㮠<literal><class></literal> 宣言を使ã£ã¦ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã—ã‹ã—ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªé–¢é€£(例ãˆã° 階層ã®ã‚¹ãƒ¼ãƒ‘ークラスã¸ã®é–¢é€£)を使ã„ãŸã„ãªã‚‰ã€ <literal><union-subclass></literal> マッピングを使ã†å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<union-subclass
+\n"
+ " name=\"ClassName\"
+\n"
+ " table=\"tablename\"
+\n"
+ " proxy=\"ProxyInterface\"
+\n"
+ " lazy=\"true|false\"
+\n"
+ " dynamic-update=\"true|false\"
+\n"
+ " dynamic-insert=\"true|false\"
+\n"
+ " schema=\"schema\"
+\n"
+ " catalog=\"catalog\"
+\n"
+ " extends=\"SuperclassName\"
+\n"
+ " abstract=\"true|false\"
+\n"
+ " persister=\"ClassName\"
+\n"
+ " subselect=\"SQL expression\"
+\n"
+ " entity-name=\"EntityName\"
+\n"
+ " node=\"element-name\">
+\n"
+ "
+\n"
+ " <property .... />
+\n"
+ " .....
+\n"
+ "</union-subclass>]]>"
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "<literal>name</literal>：サブクラスã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸã‚¯ãƒ©ã‚¹å。"
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr "<literal>table</literal> :サブクラステーブルã®åå‰ã€‚"
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr "<literal>proxy</literal> (オプション): é…延åˆæœŸåŒ–プãƒã‚ã‚·ã«ä½¿ç”¨ã™ã‚‹ã‚¯ãƒ©ã‚¹ã‚„インターフェイスを指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr "<literal>lazy</literal> (オプション, デフォルト㯠<literal>true</literal> ): <literal>lazy=\"false\"</literal> ã¨ã™ã‚‹ã¨ã€é…延フェッãƒãŒä½¿ç”¨ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr "ã“ã®ãƒžãƒƒãƒ”ング戦略ã§ã¯è˜åˆ¥ã‚«ãƒ©ãƒ ã‚„ã‚ーカラムã¯å¿…è¦ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr "継承ã®ãƒžãƒƒãƒ”ングã«é–¢ã™ã‚‹æƒ…å ±ã¯ <xref linkend=\"inheritance\"/> を見ã¦ãã ã•ã„。"
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr "join"
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr "<literal><join></literal> è¦ç´ を使ã†ã“ã¨ã§ã€ １ã¤ã®ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティをã„ãã¤ã‚‚ã®ãƒ†ãƒ¼ãƒ–ルã«ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr ""
+ "<![CDATA[<join
+\n"
+ " table=\"tablename\"
+\n"
+ " schema=\"owner\"
+\n"
+ " catalog=\"catalog\"
+\n"
+ " fetch=\"join|select\"
+\n"
+ " inverse=\"true|false\"
+\n"
+ " optional=\"true|false\">
+\n"
+ "
+\n"
+ " <key ... />
+\n"
+ "
+\n"
+ " <property ... />
+\n"
+ " ...
+\n"
+ "</join>]]>"
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal>table</literal> :çµåˆã—ãŸãƒ†ãƒ¼ãƒ–ルã®åå‰"
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr "<literal>schema</literal> (オプション): ルート㮠<literal><hibernate-mapping></literal> è¦ç´ ã§æŒ‡å®šã—ãŸã‚¹ã‚ーマåã‚’ オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr "<literal>catalog</literal> (オプション): ルート㮠<literal><hibernate-mapping></literal> è¦ç´ ã§æŒ‡å®šã—ãŸã‚«ã‚¿ãƒã‚°åã‚’ オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr "<literal>fetch</literal> (オプション - デフォルト㯠<literal>join</literal> ): <literal>join</literal> ã‚’è¨å®šã—ãŸå ´åˆã€ Hibernateã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã€ã‚¯ãƒ©ã‚¹ã‚„スーパークラスã§å®šç¾©ã•ã‚ŒãŸ <literal><join></literal> を検索ã™ã‚‹ã®ã«å†…部çµåˆã‚’使ã„ã€ã‚µãƒ–クラスã§å®šç¾©ã•ã‚ŒãŸ <literal><join></literal> を検索ã™ã‚‹ã®ã«å¤–部çµåˆã‚’使ã„ã¾ã™ã€‚ <literal>select</literal> ã‚’è¨å®šã—ãŸå ´åˆã«ã¯ã€ Hibernateã¯ã‚µãƒ–クラスã§å®šç¾©ã•ã‚ŒãŸ <literal><join></literal> ã®é¸æŠžã«é †æ¬¡é¸æŠžã‚’使ã„ã¾ã™ã€‚ã“ã®å ´åˆã€ è¡ŒãŒã‚µãƒ–クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’代表ã™ã‚‹ã“ã¨ãŒã‚ã‹ã£ãŸå ´åˆã«ã®ã¿ç™ºè¡Œã•ã‚Œã¾ã™ã€‚ 内部çµåˆã¯ã‚¯ãƒ©ã‚¹ã‚„ãã®ã‚¹ãƒ¼ãƒ‘ークラスã§å®šç¾©ã•ã‚ŒãŸ <literal><join></literal> を検索 ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr "<literal>inverse</literal> (オプション - デフォルト㯠<literal>false</literal> ): ã‚‚ã—å¯èƒ½ã§ã‚ã‚Œã°ã€Hibernateã¯ã“ã®çµåˆã§å®šç¾©ã•ã‚Œã¦ã„るプãƒãƒ‘ティã«å¯¾ã— 挿入や更新を行ã„ã¾ã›ã‚“。"
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr "<literal>optional</literal> (オプション - デフォルト㯠<literal>false</literal> ): ã‚‚ã—å¯èƒ½ã§ã‚ã‚Œã°ã€Hibernateã¯ã“ã®çµåˆã§å®šç¾©ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティãŒnullã§ãªã„å ´åˆã«ã®ã¿ 行を挿入ã—ã€ãã®ãƒ—ãƒãƒ‘ティã®æ¤œç´¢ã«ã¯å¸¸ã«å¤–部çµåˆã‚’使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr ""
+ "<![CDATA[<class name=\"Person\"
+\n"
+ " table=\"PERSON\">
+\n"
+ "
+\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>
+\n"
+ "
+\n"
+ " <join table=\"ADDRESS\">
+\n"
+ " <key column=\"ADDRESS_ID\"/>
+\n"
+ " <property name=\"address\"/>
+\n"
+ " <property name=\"zip\"/>
+\n"
+ " <property name=\"country\"/>
+\n"
+ " </join>
+\n"
+ " ...]]>"
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr "今ã¾ã§ä½•åº¦ã‹ <literal><key></literal> è¦ç´ ãŒå‡ºã¦ãã¾ã—ãŸã€‚ ã“ã®è¦ç´ ã¯æ–°ã—ã„テーブルã¸ã®çµåˆã‚’定義ã—ãŸã‚Šã€ çµåˆãƒ†ãƒ¼ãƒ–ルã§å¤–部ã‚ーを定義ã—ãŸã‚Šã™ã‚‹è¦ªè¦ç´ ã®ã©ã“ã«ã§ã‚‚ç¾ã‚Œã€ オリジナルテーブルã®ä¸»ã‚ーをå‚ç…§ã—ã¾ã™ã€‚"
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<key
+\n"
+ " column=\"columnname\"
+\n"
+ " on-delete=\"noaction|cascade\"
+\n"
+ " property-ref=\"propertyName\"
+\n"
+ " not-null=\"true|false\"
+\n"
+ " update=\"true|false\"
+\n"
+ " unique=\"true|false\"
+\n"
+ "/>]]>"
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr "<literal>on-delete</literal> (オプション, デフォルト㯠<literal>noaction</literal>): 外部ã‚ー制約ãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ¬ãƒ™ãƒ«ã§ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰å‰Šé™¤ãŒå¯èƒ½ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr "<literal>property-ref</literal> (オプション): オリジナルテーブルã®ä¸»ã‚ーã§ã¯ãªã„カラムをå‚ç…§ã™ã‚‹å¤–部ã‚ーを指定ã—ã¾ã™ (レガシーデータã«å¯¾ã—ã¦æä¾›ã•ã‚Œã¾ã™)。"
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr "<literal>not-null</literal> (オプション): 外部ã‚ーカラムãŒnull値を許容ã—ãªã„ã“ã¨ã‚’指定ã—ã¾ã™ (ã“ã®ã“ã¨ã¯å¤–部ã‚ーãŒä¸»ã‚ーã®ä¸€éƒ¨ã§ã‚ã‚‹ã“ã¨ã‚’暗黙的ã«ç¤ºã—ã¾ã™)。"
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr "column 㨠formula è¦ç´ "
+
+#: index.docbook:2179
+msgid "join"
+msgstr ""
+ "<![CDATA[<column
+\n"
+ " name=\"column_name\"
+\n"
+ " length=\"N\"
+\n"
+ " precision=\"N\"
+\n"
+ " scale=\"N\"
+\n"
+ " not-null=\"true|false\"
+\n"
+ " unique=\"true|false\"
+\n"
+ " unique-key=\"multicolumn_unique_key_name\"
+\n"
+ " index=\"index_name\"
+\n"
+ " sql-type=\"sql_type_name\"
+\n"
+ " check=\"SQL expression\"
+\n"
+ " default=\"SQL expression\"/>]]>"
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr "<![CDATA[<formula>SQL expression</formula>]]>"
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr "åŒã˜ãƒ—ãƒãƒ‘ティや関連ã®ãƒžãƒƒãƒ”ングã®ä¸ã§ã€ <literal>column</literal> 㨠<literal>formula</literal> 属性を組ã¿åˆã‚ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ 例ãˆã°ã€ç‰¹æ®Šãªçµåˆæ¡ä»¶ãªã©ã§ã™ã€‚"
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"
+\n"
+ " insert=\"false\" update=\"false\">
+\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>
+\n"
+ " <formula>'MAILING'</formula>
+\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr ""
+ "<![CDATA[<import
+\n"
+ " class=\"ClassName\"
+\n"
+ " rename=\"ShortName\"
+\n"
+ "/>]]>"
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr "<literal>class</literal>：Javaクラスã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸã‚¯ãƒ©ã‚¹å。"
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr "<literal>rename</literal>（オプション - デフォルトã¯ä¿®é£¾ã•ã‚Œã¦ã„ãªã„クラスå）： クエリ言語ã§ä½¿ã‚れるåå‰ã€‚"
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr "<title>any</title>"
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "プãƒãƒ‘ティマッピングã«ã¯ã•ã‚‰ã«ã‚‚ã†1ã¤ã®åž‹ãŒã‚ã‚Šã¾ã™ã€‚ <literal><any></literal> マッピングè¦ç´ ã¯ã€ 複数ã®ãƒ†ãƒ¼ãƒ–ルã‹ã‚‰ã‚¯ãƒ©ã‚¹ã¸ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªé–¢é€£ã‚’定義ã—ã¾ã™ã€‚ ã“ã®åž‹ã®ãƒžãƒƒãƒ”ングã«ã¯å¿…ãšè¤‡æ•°ã®ã‚«ãƒ©ãƒ ãŒå¿…è¦ã§ã™ã€‚1番目ã®ã‚«ãƒ©ãƒ ã¯é–¢é€£ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®åž‹ã‚’ä¿æŒã—ã¾ã™ã€‚ 残りã®ã‚«ãƒ©ãƒ ã¯è˜åˆ¥åã‚’ä¿æŒã—ã¾ã™ã€‚ã“ã®ç¨®é¡žã®é–¢é€£ã«ã¯å¤–部ã‚ー制約を指定ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 ãã®ãŸã‚ã“ã‚Œã¯æœ€ã‚‚使ã‚れるã“ã¨ã®ãªã„（ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªï¼‰é–¢é€£ã®ãƒžãƒƒãƒ”ング方法ã§ã™ã€‚ éžå¸¸ã«ç‰¹åˆ¥ãªå ´åˆï¼ˆä¾‹ãˆã°ã€æ¤œæŸ»ãƒã‚°ã‚„ユーザセッションデータãªã©)ã«é™ã£ã¦ã€ã“れを使ã†ã¹ãã§ã™ã€‚"
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr "<literal>meta-type</literal> ã«ã‚ˆã‚Šã€ アプリケーションã¯ã‚«ã‚¹ã‚¿ãƒ 型を指定ã§ãã¾ã™ã€‚ã“ã®ã‚«ã‚¹ã‚¿ãƒ 型㯠データベースカラムã®å€¤ã‚’ã€<literal>id-type</literal> ã§æŒ‡å®šã—ãŸåž‹ã® è˜åˆ¥åプãƒãƒ‘ティをæŒã£ãŸæ°¸ç¶šã‚¯ãƒ©ã‚¹ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚ meta-typeã®å€¤ã‹ã‚‰ã‚¯ãƒ©ã‚¹åã¸ã®ãƒžãƒƒãƒ”ングを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">
+\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>
+\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>
+\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>
+\n"
+ " <column name=\"table_name\"/>
+\n"
+ " <column name=\"id\"/>
+\n"
+ "</any>]]>"
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr ""
+ "<![CDATA[<any
+\n"
+ " name=\"propertyName\"
+\n"
+ " id-type=\"idtypename\"
+\n"
+ " meta-type=\"metatypename\"
+\n"
+ " cascade=\"cascade_style\"
+\n"
+ " access=\"field|property|ClassName\"
+\n"
+ " optimistic-lock=\"true|false\"
+\n"
+ ">
+\n"
+ " <meta-value ... />
+\n"
+ " <meta-value ... />
+\n"
+ " .....
+\n"
+ " <column .... />
+\n"
+ " <column .... />
+\n"
+ " .....
+\n"
+ "</any>]]>"
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr "<literal>id-type</literal>：è˜åˆ¥åã®åž‹ã€‚"
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr "<literal>meta-type</literal>（オプション - デフォルト㯠<literal>string</literal> ）： ディスクリミãƒãƒ¼ã‚¿ãƒžãƒƒãƒ”ングã§è¨±ã•ã‚ŒãŸåž‹"
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "<literal>cascade</literal>（オプション - デフォルト㯠<literal>none</literal> ）： カスケードã®ã‚¹ã‚¿ã‚¤ãƒ«ã€‚"
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "<literal>access</literal>（オプション - デフォルト㯠<literal>property</literal> ）： プãƒãƒ‘ティã®å€¤ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã«HibernateãŒä½¿ã†æˆ¦ç•¥ã€‚"
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr "<literal>optimistic-lock</literal> (オプション - デフォルト㯠<literal>true</literal> ): ã“ã®ãƒ—ãƒãƒ‘ティã®æ›´æ–°ã«æ¥½è¦³ãƒãƒƒã‚¯ã®å–å¾—ã‚’è¦æ±‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ã“ã®ãƒ—ãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹ã¨ãã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’増やã™ã¹ãã‹ã‚’定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "Hibernateã®åž‹"
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr "エンティティã¨å€¤"
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr "永続サービスã«é–¢ã‚る様々ãªJava言語レベルã®ã‚ªãƒ–ジェクトã®æŒ¯ã‚‹èˆžã„ã‚’ç†è§£ã™ã‚‹ãŸã‚ã«ã¯ã€ オブジェクトを2ã¤ã®ã‚°ãƒ«ãƒ¼ãƒ—ã«åˆ†ã‘ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr "<emphasis> エンティティ</emphasis> ã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚照をä¿æŒã™ã‚‹ã€ ä»–ã®ã™ã¹ã¦ã®ã‚ªãƒ–ジェクトã‹ã‚‰ç‹¬ç«‹ã—ã¦å˜åœ¨ã—ã¾ã™ã€‚ å‚ç…§ã•ã‚Œãªã„オブジェクトãŒã‚¬ãƒ™ãƒ¼ã‚¸ã‚³ãƒ¬ã‚¯ãƒˆã•ã‚Œã¦ã—ã¾ã†æ€§è³ªã‚’æŒã¤é€šå¸¸ã®Javaモデルã¨ã€ ã“れを比ã¹ã¦ã¿ã¦ãã ã•ã„。 （親エンティティã‹ã‚‰åã¸ã€ã‚»ãƒ¼ãƒ–ã¨å‰Šé™¤ãŒ <emphasis>カスケード</emphasis> ã•ã‚Œã†ã‚‹ã“ã¨ã‚’除ã„ã¦ï¼‰ エンティティã¯æ˜Žç¤ºçš„ã«ã‚»ãƒ¼ãƒ–ã¾ãŸã¯å‰Šé™¤ã•ã‚Œãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã“ã‚Œã¯åˆ°é”å¯èƒ½æ€§ã«ã‚ˆã‚‹ã‚ªãƒ–ジェクト永続化ã®ODMGモデルã¨ã¯ç•°ãªã£ã¦ã„ã¾ã™ã€‚ 大è¦æ¨¡ãªã‚·ã‚¹ãƒ†ãƒ ã§ã‚¢ãƒ—リケーションオブジェクトãŒæ™®é€šã©ã®ã‚ˆã†ã«ä½¿ã‚れるã‹ã«ã‚ˆã‚Šå¯†æŽ¥ã«å¯¾å¿œã—ã¾ã™ã€‚ エンティティã¯å¾ªç’°ã¨å‚ç…§ã®å…±æœ‰ã‚’サãƒãƒ¼ãƒˆã—ã¾ã™ã€‚ ã¾ãŸãれらã¯ãƒãƒ¼ã‚¸ãƒ§ãƒ³ä»˜ã‘ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr "エンティティã®æ°¸ç¶šçŠ¶æ…‹ã¯ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„ <emphasis>値</emphasis> 型㮠インスタンスã¸ã®å‚ç…§ã‹ã‚‰æ§‹æˆã•ã‚Œã¾ã™ã€‚ 値ã¯ãƒ—リミティブã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³(コレクションã®å†…部ã§ã¯ãªã)〠コンãƒãƒ¼ãƒãƒ³ãƒˆã€ä¸å¤‰ã‚ªãƒ–ジェクトã§ã™ã€‚ エンティティã¨ã¯é•ã„ã€å€¤ã¯ï¼ˆç‰¹ã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¨ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã«ãŠã„ã¦ï¼‰ã€ 到é”å¯èƒ½æ€§ã«ã‚ˆã‚‹æ°¸ç¶šåŒ–や削除㌠<emphasis>è¡Œã‚ã‚Œã¾ã™</emphasis> 。 値オブジェクト（ã¨ãƒ—リミティブ）ã¯ã€åŒ…å«ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨ä¸€ç·’ã«æ°¸ç¶šåŒ–や削除ãŒè¡Œã‚れるã®ã§ã€ ãれらを独立ã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ä»˜ã‘ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 値ã«ã¯ç‹¬ç«‹ã—ãŸã‚¢ã‚¤ãƒ‡ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒãªã„ã®ã§ã€ 複数ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„コレクションãŒã“れを共有ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr "ã“ã‚Œã¾ã§ã€Œæ°¸ç¶šã‚¯ãƒ©ã‚¹ã€ã¨ã„ã†è¨€è‘‰ã‚’エンティティã®æ„味ã§ä½¿ã£ã¦ãã¾ã—ãŸã€‚ ã“ã‚Œã‹ã‚‰ã‚‚ãã†ã—ã¦ã„ãã¾ã™ã€‚ 厳密ã«è¨€ã†ã¨ã€æ°¸ç¶šçŠ¶æ…‹ã‚’æŒã¤ãƒ¦ãƒ¼ã‚¶å®šç¾©ã®ã‚¯ãƒ©ã‚¹ã®ã™ã¹ã¦ãŒ エンティティã¨ã„ã†ã‚ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 <emphasis>コンãƒãƒ¼ãƒãƒ³ãƒˆ</emphasis> ã¯å€¤ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’æŒã¤ãƒ¦ãƒ¼ã‚¶å®šç¾©ã‚¯ãƒ©ã‚¹ã§ã™ã€‚ <literal>java.lang.String</literal> åž‹ã®ãƒ—ãƒãƒ‘ティもã¾ãŸå€¤ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’æŒã¡ã¾ã™ã€‚ 定義ã™ã‚‹ãªã‚‰ã€JDKã§æä¾›ã•ã‚Œã¦ã„ã‚‹ã™ã¹ã¦ã®Javaã®åž‹(クラス)ãŒå€¤ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’æŒã¤ã¨ã„ãˆã¾ã™ã€‚ 一方ユーザ定義型ã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„値型ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã¨ã¨ã‚‚ã«ãƒžãƒƒãƒ”ングã§ãã¾ã™ã€‚ ã“ã®æ±ºå®šã¯ã‚¢ãƒ—リケーション開発者次第ã§ã™ã€‚ ãã®ã‚¯ãƒ©ã‚¹ã®ï¼‘ã¤ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¸ã®å…±æœ‰å‚ç…§ã¯ã€ ドメインモデル内ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ã«å¯¾ã™!
る良ã„ヒントã«ãªã‚Šã¾ã™ã€‚ 一方åˆæˆé›†ç´„や集約ã¯ã€é€šå¸¸å€¤åž‹ã¸å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "本ドã‚ュメントを通ã—ã¦ã€ä½•åº¦ã‚‚ã“ã®æ¦‚念をå–り上ã’ã¾ã™ã€‚"
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr "Javaåž‹ã®ã‚·ã‚¹ãƒ†ãƒ (ã‚‚ã—ãã¯é–‹ç™ºè€…ãŒå®šç¾©ã—ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨å€¤åž‹)ã‚’ SQL/データベース型ã®ã‚·ã‚¹ãƒ†ãƒ ã«ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ã¯é›£ã—ã„ã§ã™ã€‚ Hibernateã¯ï¼’ã¤ã®ã‚·ã‚¹ãƒ†ãƒ ã®æž¶ã‘æ©‹ã‚’æä¾›ã—ã¾ã™ã€‚ エンティティã«å¯¾ã—ã¦ã¯ <literal><class></literal> ã‚„ <literal><subclass></literal> ãªã©ã‚’使用ã—ã¾ã™ã€‚ 値型ã«å¯¾ã—ã¦ã¯ <literal><property></literal> ã‚„ <literal><component></literal> ãªã©ã‚’ã€é€šå¸¸ <literal>type</literal> ã¨ã¨ã‚‚ã«ä½¿ã„ã¾ã™ã€‚ ã“ã®å±žæ€§ã®å€¤ã¯Hibernateã® <emphasis>マッピング型</emphasis> ã®åå‰ã§ã™ã€‚ Hibernateã¯(標準JDKã®å€¤åž‹ã«å¯¾ã—ã¦)多ãã®è‡ªç”±ãªãƒžãƒƒãƒ”ングをæä¾›ã—ã¾ã™ã€‚ 後ã§è¦‹ã‚‹ã‚ˆã†ã«ã€è‡ªèº«ã®ãƒžãƒƒãƒ”ング型を記述ã—ã€åŒæ§˜ã«ã‚«ã‚¹ã‚¿ãƒ ã®å¤‰æ›æˆ¦ç•¥ã‚’実装ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:2367
+msgid "import"
+msgstr "コレクションを除ã組ã¿è¾¼ã¿ã®Hibernateã®åž‹ã¯ã™ã¹ã¦ã€nullセマンティクスをサãƒãƒ¼ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr "基本的ãªåž‹"
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr "組ã¿è¾¼ã¿ã® <emphasis>基本的ãªãƒžãƒƒãƒ”ング型</emphasis> ã¯å¤§ã¾ã‹ã«ä»¥ä¸‹ã®ã‚ˆã†ã«åˆ†ã‘られã¾ã™ã€‚"
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr "Javaã®ãƒ—リミティブやラッパークラスã‹ã‚‰é©åˆ‡ãªï¼ˆãƒ™ãƒ³ãƒ€ãƒ¼å›ºæœ‰ã®ï¼‰ SQLカラム型ã¸ã®åž‹ãƒžãƒƒãƒ”ング。 <literal>boolean, yes_no</literal> 㨠<literal>true_false</literal> ã¯ã€ ã™ã¹ã¦Javaã® <literal>boolean</literal> ã¾ãŸã¯ <literal>java.lang.Boolean</literal> ã®ä»£æ›¿ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‰ã§ã™ã€‚"
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr "string"
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr "<literal>java.lang.String</literal> ã‹ã‚‰ <literal>VARCHAR</literal> （ã¾ãŸã¯Oracleã® <literal>VARCHAR2</literal> ）ã¸ã®åž‹ãƒžãƒƒãƒ”ング。"
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr "date, time, timestamp"
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "<literal>java.util.Date</literal> ã¨ãã®ã‚µãƒ–クラスã‹ã‚‰SQLåž‹ã® <literal>DATE</literal>, <literal>TIME</literal> , <literal>TIMESTAMP</literal> （ã¾ãŸã¯ãれらã¨ç‰ä¾¡ãªã‚‚ã®ï¼‰ ã¸ã®åž‹ãƒžãƒƒãƒ”ング。"
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr "calendar, calendar_date"
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr "<literal>java.util.Calendar</literal> ã‹ã‚‰SQLåž‹ ã®ã€Œ <literal>TIMESTAMP</literal> , <literal>DATE</literal> (ã¾ãŸã¯ãれらã¨ç‰ä¾¡ãªã‚‚ã®ï¼‰ã¸ã®åž‹ãƒžãƒƒãƒ”ング。"
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr "big_decimal, big_integer"
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr "<literal>java.math.BigDecimal</literal> 㨠<literal>java.math.BigInteger</literal> ã‹ã‚‰ <literal>NUMERIC</literal>（ã¾ãŸã¯Oracleã® <literal>NUMBER</literal> ）ã¸ã®åž‹ãƒžãƒƒãƒ”ング。"
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr "locale, timezone, currency"
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "<literal>java.util.Locale</literal> , <literal>java.util.TimeZone</literal> , <literal>java.util.Currency</literal> ã‹ã‚‰ <literal>VARCHAR</literal> （ã¾ãŸã¯Oracleã® <literal>VARCHAR2</literal> ）ã¸ã®åž‹ãƒžãƒƒãƒ”ング。 <literal>Locale</literal> 㨠<literal>Currency</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ ãれらã®ISOコードã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚ <literal>TimeZone</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ ãれら㮠<literal>ID</literal> ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr "<literal>java.lang.Class</literal> ã‹ã‚‰ <literal>VARCHAR</literal> （ã¾ãŸã¯Oracleã® <literal>VARCHAR2</literal> ）ã¸ã®åž‹ãƒžãƒƒãƒ”ング。 <literal>Class</literal> ã¯ãã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸåå‰ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr "binary"
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr "ãƒã‚¤ãƒˆé…列ã¯ã€é©åˆ‡ãªSQLã®ãƒã‚¤ãƒŠãƒªåž‹ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr "text"
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr "é•·ã„Javaæ–‡å—列ã¯ã€SQLã® <literal>CLOB</literal> ã¾ãŸã¯ <literal>TEXT</literal> åž‹ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "serializable"
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr "シリアライズå¯èƒ½ãªJavaåž‹ã¯ã€é©åˆ‡ãªSQLã®ãƒã‚¤ãƒŠãƒªåž‹ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚ デフォルトã§åŸºæœ¬åž‹ã§ã¯ãªã„シリアライズå¯èƒ½ãªJavaクラスや インターフェイスã®åå‰ã‚’指定ã™ã‚‹ã“ã¨ã§ã€ Hibernateã®åž‹ã‚’ <literal>serializable</literal> ã¨ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr "clob, blob"
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr "JDBCクラス <literal>java.sql.Clob</literal> 㨠<literal>java.sql.Blob</literal> ã«å¯¾ã™ã‚‹åž‹ãƒžãƒƒãƒ”ング。 blobã‚„clobオブジェクトã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®å¤–ã§ã¯å†åˆ©ç”¨ã§ããªã„ãŸã‚〠アプリケーションã«ã‚ˆã£ã¦ã¯ä¸ä¾¿ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 （ã•ã‚‰ã«ã¯ãƒ‰ãƒ©ã‚¤ãƒã‚µãƒãƒ¼ãƒˆãŒä¸€è²«ã—ã¦ã„ã¾ã›ã‚“。）"
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr "ã»ã¨ã‚“ã©ã®å ´åˆã«å¯å¤‰ã§ã‚ã‚‹Javaã®åž‹ã«å¯¾ã™ã‚‹åž‹ãƒžãƒƒãƒ”ング。 Hibernateã¯ä¸å¤‰ãªJavaã®åž‹ã«å¯¾ã—ã¦ã¯æœ€é©åŒ–ã‚’è¡Œã„〠アプリケーションã¯ãれをä¸å¤‰ã‚ªãƒ–ジェクトã¨ã—ã¦æ‰±ã„ã¾ã™ã€‚ 例ãˆã° <literal>imm_timestamp</literal> ã¨ã—ã¦ãƒžãƒƒãƒ—ã—ãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«å¯¾ã—ã¦ã€ <literal>Date.setTime()</literal> を呼ã³å‡ºã—ã¦ã¯ãªã‚Šã¾ã›ã‚“。 プãƒãƒ‘ティã®å€¤ã‚’変更ã—ãã®å¤‰æ›´ã‚’永続化ã™ã‚‹ãŸã‚ã«ã¯ã€ アプリケーションã¯ãƒ—ãƒãƒ‘ティã«å¯¾ã—ã¦æ–°ã—ã„(åŒä¸€ã§ãªã„)オブジェクトを割り当ã¦ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr "エンティティã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åã¯ã€<literal>binary</literal> , <literal>blob</literal> , <literal>clob</literal> を除ãã€ã©ã‚“ãªåŸºæœ¬åž‹ã§ã‚‚構ã„ã¾ã›ã‚“。 （複åˆè˜åˆ¥åã§ã‚‚構ã„ã¾ã›ã‚“。以下を見ã¦ãã ã•ã„。）"
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr "基本的ãªå€¤åž‹ã«ã¯ã€<literal>org.hibernate.Hibernate</literal> ã§å®šç¾©ã•ã‚ŒãŸ <literal>Type</literal> 定数ãŒãã‚Œãžã‚Œã‚ã‚Šã¾ã™ã€‚ 例ãˆã°ã€<literal>Hibernate.STRING</literal> 㯠<literal>string</literal> 型を表ç¾ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "カスタム型"
+
+#: index.docbook:2567
+msgid "string"
+msgstr "開発者ãŒç‹¬è‡ªã®å€¤åž‹ã‚’作æˆã™ã‚‹ã“ã¨ã¯ã€æ¯”較的簡å˜ã§ã™ã€‚ 例ãˆã°ã€<literal>java.lang.BigInteger</literal> åž‹ã®ãƒ—ãƒãƒ‘ティを <literal>VARCHAR</literal> カラムã«æ°¸ç¶šåŒ–ã—ãŸã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 Hibernateã¯ã“ã®ãŸã‚ã®çµ„ã¿è¾¼ã¿åž‹ã‚’用æ„ã—ã¦ã„ã¾ã›ã‚“。 ã—ã‹ã—カスタム型ã¯ã€ãƒ—ãƒãƒ‘ティ（ã¾ãŸã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ）を1ã¤ã®ãƒ†ãƒ¼ãƒ–ルカラム㫠マッピングã™ã‚‹ã®ã«åˆ¶é™ã¯ã‚ã‚Šã¾ã›ã‚“。 ãã®ãŸã‚例ãˆã°ã€<literal>java.lang.String</literal> åž‹ã® <literal>getName()</literal> / <literal>setName()</literal> Javaプãƒãƒ‘ティを <literal>FIRST_NAME</literal> , <literal>INITIAL</literal>, <literal>SURNAME</literal> カラムã«æ°¸ç¶šåŒ–ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr "カスタム型を実装ã™ã‚‹ã«ã¯ã€<literal>org.hibernate.UserType</literal> ã¾ãŸã¯ <literal>org.hibernate.CompositeUserType</literal> を実装ã—〠型ã®å®Œå…¨ä¿®é£¾ã•ã‚ŒãŸåå‰ã‚’使ã£ã¦ãƒ—ãƒãƒ‘ティを定義ã—ã¾ã™ã€‚ ã©ã®ã‚ˆã†ãªç¨®é¡žã®ã‚‚ã®ãŒå¯èƒ½ã‹ã‚’調ã¹ã‚‹ã«ã¯ã€ <literal>org.hibernate.test.DoubleStringType</literal> を確èªã—ã¦ãã ã•ã„。"
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">
+\n"
+ " <column name=\"first_string\"/>
+\n"
+ " <column name=\"second_string\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr "<literal><column></literal> ã‚¿ã‚°ã§ã€ プãƒãƒ‘ティを複数ã®ã‚«ãƒ©ãƒ ã¸ãƒžãƒƒãƒ”ングã§ãã‚‹ã“ã¨ã«æ³¨ç›®ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr "<literal>CompositeUserType</literal> , <literal>EnhancedUserType</literal> , <literal>UserCollectionType</literal> , <literal>UserVersionType</literal> インターフェイスã¯ã€ã‚ˆã‚Šç‰¹æ®Šãªä½¿ç”¨æ³•ã«å¯¾ã—ã¦ã®ã‚µãƒãƒ¼ãƒˆã‚’æä¾›ã—ã¾ã™ã€‚"
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "マッピングファイル内㧠<literal>UserType</literal> ã¸ãƒ‘ラメータをæä¾›ã§ãã¾ã™ã€‚ ã“ã®ãŸã‚ã«ã¯ã€<literal>UserType</literal> 㯠<literal>org.hibernate.usertype.ParameterizedType</literal> を実装ã—ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。 カスタム型パラメータをæä¾›ã™ã‚‹ãŸã‚ã«ã€ マッピングファイル内㧠<literal><type></literal> è¦ç´ を使用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr ""
+ "<![CDATA[<property name=\"priority\">
+\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">
+\n"
+ " <param name=\"default\">0</param>
+\n"
+ " </type>
+\n"
+ "</property>]]>"
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "<literal>UserType</literal> ã¯ã€ 引数ã¨ã—ã¦æ¸¡ã•ã‚ŒãŸ <literal>Properties</literal> オブジェクトã‹ã‚‰ã€ <literal>default</literal> ã§æŒ‡å®šã—ãŸãƒ‘ラメータã«å¯¾ã™ã‚‹å€¤ã‚’検索ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr "特定㮠<literal>UserType</literal> ã‚’é »ç¹ã«ä½¿ç”¨ã™ã‚‹ãªã‚‰ã°ã€çŸã„åå‰ã‚’定義ã™ã‚‹ã¨ä¾¿åˆ©ã«ãªã‚‹ã§ã—ょã†ã€‚ <literal><typedef></literal> è¦ç´ を使ã£ã¦ã“ã®ã‚ˆã†ãªã“ã¨ãŒè¡Œãˆã¾ã™ã€‚ Typedefsã¯ã‚«ã‚¹ã‚¿ãƒ åž‹ã«åå‰ã‚’割り当ã¦ã¾ã™ã€‚ ãã®åž‹ãŒãƒ‘ラメータをæŒã¤ãªã‚‰ã°ã€ パラメータã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã®ãƒªã‚¹ãƒˆã‚’å«ã‚€ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">
+\n"
+ " <param name=\"default\">0</param>
+\n"
+ "</typedef>]]>"
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr "プãƒãƒ‘ティã®ãƒžãƒƒãƒ”ングã§åž‹ãƒ‘ラメータを使ã†ã“ã¨ã§ã€ typedefã§æä¾›ã•ã‚ŒãŸãƒ‘ラメータをãã®éƒ½åº¦ã‚ªãƒ¼ãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã™ã‚‹ã“ã¨ãŒå¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:2630
+msgid "binary"
+msgstr "Hibernateã®å¹…広ã„組ã¿è¾¼ã¿åž‹ã¨ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã«å¯¾ã™ã‚‹ã‚µãƒãƒ¼ãƒˆã¯ã€ カスタム型をã‚ã£ãŸã« <emphasis>使ã‚ãªã„</emphasis> ã¨ã„ã†ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚ ãã‚Œã§ã‚‚ãªãŠã€ã‚¢ãƒ—リケーションã§é »å‡ºã™ã‚‹(エンティティã§ã¯ãªã„)クラスã«å¯¾ã™ã‚‹ã‚«ã‚¹ã‚¿ãƒ åž‹ã®ä½¿ç”¨ã¯ã€ よã„ã‚„ã‚Šæ–¹ã§ã‚ã‚‹ã¨ã¿ãªã•ã‚Œã¾ã™ã€‚ 例ãˆã° <literal>MonetaryAmount</literal> クラスã¯ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¨ã—ã¦ç°¡å˜ã«ãƒžãƒƒãƒ”ングã§ãã¾ã™ãŒã€ <literal>CompositeUserType</literal> ã®è‰¯ã„候補ã§ã™ã€‚ カスタム型を使用ã™ã‚‹å‹•æ©Ÿã®1ã¤ã¯æŠ½è±¡åŒ–ã§ã™ã€‚ カスタム型を使ã†ã“ã¨ã§ã€é€šè²¨ã‚’ã©ã®ã‚ˆã†ã«è¡¨ç¾ã—よã†ã¨ã‚‚ マッピングドã‚ュメントã¯èµ·ã“ã‚Šã†ã‚‹å¤‰åŒ–ã«å¯¾å¿œã§ãã¾ã™ã€‚"
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr "１ã¤ã®ã‚¯ãƒ©ã‚¹ã«ï¼‘ã¤ä»¥ä¸Šã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:2638
+msgid "text"
+msgstr "ã‚る永続クラスã«ã€ä¸€ã¤ä»¥ä¸Šã®ãƒžãƒƒãƒ”ングをæä¾›ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ ã“ã®å ´åˆã€ãƒžãƒƒãƒ”ングã™ã‚‹ï¼’ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’明確ã«ã™ã‚‹ãŸã‚ã«ã€ <emphasis>エンティティå</emphasis> を指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“ (デフォルトã§ã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£åã¯ã‚¯ãƒ©ã‚¹åã¨åŒã˜ã§ã™ã€‚)。 永続オブジェクトを扱ã†ã¨ãã€ã‚¯ã‚¨ãƒªã‚’書ã込むã¨ã〠指定ã•ã‚ŒãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®é–¢é€£ã‚’マッピングã™ã‚‹ã¨ãã«ã¯ã€ Hibernateã§ã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£åを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"
+\n"
+ " entity-name=\"CurrentContract\">
+\n"
+ " ...
+\n"
+ " <set name=\"history\" inverse=\"true\"
+\n"
+ " order-by=\"effectiveEndDate desc\">
+\n"
+ " <key column=\"currentContractId\"/>
+\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"
+\n"
+ " entity-name=\"HistoricalContract\">
+\n"
+ " ...
+\n"
+ " <many-to-one name=\"currentContract\"
+\n"
+ " column=\"currentContractId\"
+\n"
+ " entity-name=\"CurrentContract\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr "関連ãŒ<literal>class</literal> ã®ä»£ã‚ã‚Šã« <literal>entity-name</literal> を使ã£ã¦ã€ ã©ã®ã‚ˆã†ã«æŒ‡å®šã•ã‚Œã‚‹ã®ã‹ã«æ³¨ç›®ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr "ãƒãƒƒã‚¯ã‚¯ã‚©ãƒ¼ãƒˆã§å›²ã‚“ã SQL è˜åˆ¥å"
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr "マッピングドã‚ュメントã§ãƒ†ãƒ¼ãƒ–ルやカラムã®åå‰ã‚’ãƒãƒƒã‚¯ã‚¯ã‚©ãƒ¼ãƒˆã§å›²ã‚€ã“ã¨ã§ã€ Hibernateã§ç”Ÿæˆã•ã‚ŒãŸSQLä¸ã®è˜åˆ¥åを引用ã•ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ Hibernateã¯SQLã® <literal>Dialect</literal> ã«å¯¾å¿œã™ã‚‹ã€æ£ã—ã„引用スタイルを使ã„ã¾ã™ （普通ã¯ãƒ€ãƒ–ルクォートã§ã™ãŒã€SQL Serverã§ã¯ã‹ãŽæ‹¬å¼§ã€MySQLã§ã¯ãƒãƒƒã‚¯ã‚¯ã‚©ãƒ¼ãƒˆã§ã™ï¼‰ã€‚"
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">
+\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>
+\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>
+\n"
+ " ...
+\n"
+ "</class>]]>"
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr "メタデータã®ä»£æ›¿æ‰‹æ®µ"
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr "XMLã®è¨˜è¿°ä»¥å¤–ã«ã€ Hibernateã§ã¯O/Rマッピングã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’定義ã™ã‚‹ä»£æ›¿æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr "XDoclet マークアップã®ä½¿ç”¨"
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr "多ãã®Hibernateユーザã¯XDocletã® <literal>@hibernate.tags</literal> を使ã£ã¦ã€ ソースコード内ã«ç›´æŽ¥ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã‚’åŸ‹ã‚込むã“ã¨ã‚’好ã¿ã¾ã™ã€‚ ã“ã‚Œã¯åŽ³å¯†ã«è¨€ãˆã°XDocletã®åˆ†é‡Žãªã®ã§ã€æœ¬ãƒ‰ã‚ュメントã§ã¯ã“ã®æ–¹æ³•ã‚’対象ã¨ã¯ã—ã¾ã›ã‚“。 ã—ã‹ã—XDocletを使ã£ãŸä»¥ä¸‹ã® <literal>Cat</literal> マッピングã®ä¾‹ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "import java.util.Set;
+\n"
+ "import java.util.Date;
+\n"
+ "
+\n"
+ "/**
+\n"
+ " * @hibernate.class
+\n"
+ " * table=\"CATS\"
+\n"
+ " */
+\n"
+ "public class Cat {
+\n"
+ " private Long id; // identifier
+\n"
+ " private Date birthdate;
+\n"
+ " private Cat mother;
+\n"
+ " private Set kittens
+\n"
+ " private Color color;
+\n"
+ " private char sex;
+\n"
+ " private float weight;
+\n"
+ "
+\n"
+ " /*
+\n"
+ " * @hibernate.id
+\n"
+ " * generator-class=\"native\"
+\n"
+ " * column=\"CAT_ID\"
+\n"
+ " */
+\n"
+ " public Long getId() {
+\n"
+ " return id;
+\n"
+ " }
+\n"
+ " private void setId(Long id) {
+\n"
+ " this.id=id;
+\n"
+ " }
+\n"
+ "
+\n"
+ " /**
+\n"
+ " * @hibernate.many-to-one
+\n"
+ " * column=\"PARENT_ID\"
+\n"
+ " */
+\n"
+ " public Cat getMother() {
+\n"
+ " return mother;
+\n"
+ " }
+\n"
+ " void setMother(Cat mother) {
+\n"
+ " this.mother = mother;
+\n"
+ " }
+\n"
+ "
+\n"
+ " /**
+\n"
+ " * @hibernate.property
+\n"
+ " * column=\"BIRTH_DATE\"
+\n"
+ " */
+\n"
+ " public Date getBirthdate() {
+\n"
+ " return birthdate;
+\n"
+ " }
+\n"
+ " void setBirthdate(Date date) {
+\n"
+ " birthdate = date;
+\n"
+ " }
+\n"
+ " /**
+\n"
+ " * @hibernate.property
+\n"
+ " * column=\"WEIGHT\"
+\n"
+ " */
+\n"
+ " public float getWeight() {
+\n"
+ " return weight;
+\n"
+ " }
+\n"
+ " void setWeight(float weight) {
+\n"
+ " this.weight = weight;
+\n"
+ " }
+\n"
+ "
+\n"
+ " /**
+\n"
+ " * @hibernate.property
+\n"
+ " * column=\"COLOR\"
+\n"
+ " * not-null=\"true\"
+\n"
+ " */
+\n"
+ " public Color getColor() {
+\n"
+ " return color;
+\n"
+ " }
+\n"
+ " void setColor(Color color) {
+\n"
+ " this.color = color;
+\n"
+ " }
+\n"
+ " /**
+\n"
+ " * @hibernate.set
+\n"
+ " * inverse=\"true\"
+\n"
+ " * order-by=\"BIRTH_DATE\"
+\n"
+ " * @hibernate.collection-key
+\n"
+ " * column=\"PARENT_ID\"
+\n"
+ " * @hibernate.collection-one-to-many
+\n"
+ " */
+\n"
+ " public Set getKittens() {
+\n"
+ " return kittens;
+\n"
+ " }
+\n"
+ " void setKittens(Set kittens) {
+\n"
+ " this.kittens = kittens;
+\n"
+ " }
+\n"
+ " // addKitten not needed by Hibernate
+\n"
+ " public void addKitten(Cat kitten) {
+\n"
+ " kittens.add(kitten);
+\n"
+ " }
+\n"
+ "
+\n"
+ " /**
+\n"
+ " * @hibernate.property
+\n"
+ " * column=\"SEX\"
+\n"
+ " * not-null=\"true\"
+\n"
+ " * update=\"false\"
+\n"
+ " */
+\n"
+ " public char getSex() {
+\n"
+ " return sex;
+\n"
+ " }
+\n"
+ " void setSex(char sex) {
+\n"
+ " this.sex=sex;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr "Hibernateã®ã‚¦ã‚§ãƒ–サイトã«ã¯ã€XDocletã¨Hibernateã«é–¢ã™ã‚‹ã‚µãƒ³ãƒ—ルãŒå¤šæ•°ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr "JDK 5.0 アノテーションã®ä½¿ç”¨"
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr "JDK5.0ã§ã¯ã‚¿ã‚¤ãƒ—セーフã‹ã¤ã‚³ãƒ³ãƒ‘イル時ã«ãƒã‚§ãƒƒã‚¯ã§ãる〠言語レベルã®XDocletスタイルã®ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³ã‚’å°Žå…¥ã—ã¾ã—ãŸã€‚ ã“ã®ãƒ¡ã‚«ãƒ‹ã‚ºãƒ ã¯XDocletã®ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³ã‚ˆã‚Šã‚‚強力ã§ã€ãƒ„ールやIDEも多ããŒã‚µãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ 例ãˆã°IntelliJ IDEAã¯ã€JDK5.0ã«ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³ã®è‡ªå‹•è£œå®Œã¨æ§‹æ–‡ã®å¼·èª¿è¡¨ç¤ºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ EJB仕様 (JSR-220)ã®æ–°ã—ã„ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã§ã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒ“ーンã«å¯¾ã™ã‚‹ä¸»è¦ãªãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ãƒ¡ã‚«ãƒ‹ã‚ºãƒ ã¨ã—㦠JDK5.0ã®ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³ã‚’使用ã—ã¦ã„ã¾ã™ã€‚ Hibernate3ã§ã¯JSR-220 (永続化API)ã® <literal>EntityManager</literal> を実装ã—〠メタデータマッピングã«å¯¾ã™ã‚‹ã‚µãƒãƒ¼ãƒˆã¯ã€ 別ダウンãƒãƒ¼ãƒ‰ã® <emphasis>Hibernate Annotations</emphasis> パッケージã«ã‚ˆã‚Šåˆ©ç”¨å¯èƒ½ã§ã™ã€‚ ã“ã‚Œã¯EJB3(JSR-220)ã¨Hibernate3ã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’ã©ã¡ã‚‰ã‚‚サãƒãƒ¼ãƒˆ!
ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr "以下ã¯EJBã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒ“ーンã¨ã—ã¦æ³¨é‡ˆã•ã‚ŒãŸPOJOクラスã®ä¾‹ã§ã™ã€‚"
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)
+\n"
+ "public class Customer implements Serializable {
+\n"
+ "
+\n"
+ " @Id;
+\n"
+ " Long id;
+\n"
+ "
+\n"
+ " String firstName;
+\n"
+ " String lastName;
+\n"
+ " Date birthday;
+\n"
+ "
+\n"
+ " @Transient
+\n"
+ " Integer age;
+\n"
+ "
+\n"
+ " @Embedded
+\n"
+ " private Address homeAddress;
+\n"
+ "
+\n"
+ " @OneToMany(cascade=CascadeType.ALL)
+\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")
+\n"
+ " Set<Order> orders;
+\n"
+ "
+\n"
+ " // Getter/setter and business methods
+\n"
+ "}]]>"
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr "JDK5.0ã®ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³(ã¨JSR-220)ã®ã‚µãƒãƒ¼ãƒˆã¯é€²è¡Œä¸ã®ä½œæ¥ã§ã‚ã‚Šã€å®Œå…¨ã§ã¯ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã•ã‚‰ã«è©³ã—ã„æƒ…å ±ã¯Hibernateã®ã‚¢ãƒŽãƒ†ãƒ¼ã‚·ãƒ§ãƒ³ãƒ»ãƒ¢ã‚¸ãƒ¥ãƒ¼ãƒ«ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr "生æˆãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr "生æˆãƒ—ãƒãƒ‘ティã¨ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚ˆã£ã¦ç”Ÿæˆã•ã‚ŒãŸå€¤ã‚’æŒã¤ãƒ—ãƒãƒ‘ティã§ã™ã€‚ 通常ã€Hibernateアプリケーションã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒå€¤ã‚’生æˆã—ãŸãƒ—ãƒãƒ‘ティをå«ã‚€ã‚ªãƒ–ジェクトを <literal>リフレッシュ</literal> ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã—ãŸã€‚ ã—ã‹ã—ã€ãƒ—ãƒãƒ‘ティãŒç”Ÿæˆã•ã‚ŒãŸã¨ã„ã†ã“ã¨ã‚’マークã™ã‚‹ã“ã¨ã§ã€ アプリケーションã¯ãƒªãƒ•ãƒ¬ãƒƒã‚·ãƒ¥ã®è²¬ä»»ã‚’Hibernateã«å§”è²ã—ã¾ã™ã€‚ 基本的ã«ã€ç”Ÿæˆãƒ—ãƒãƒ‘ティをæŒã¤ã¨å®šç¾©ã—ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã—㦠HibernateãŒINSERTã‚„UPDATEã®SQLを発行ã—ãŸå¾Œã™ãã«ã€ 生æˆã•ã‚ŒãŸå€¤ã‚’èªã¿è¾¼ã‚€ãŸã‚ã® SELECT SQL ãŒç™ºè¡Œã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr "生æˆãƒ—ãƒãƒ‘ティã¯ã€æŒ¿å…¥ä¸å¯èƒ½ã‹ã¤æ›´æ–°ä¸å¯èƒ½ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <xref linkend=\"mapping-declaration-version\"/>versions 〠<xref linkend=\"mapping-declaration-timestamp\"/>timestamps 〠<xref linkend=\"mapping-declaration-property\"/>simple properties ã ã‘ãŒç”Ÿæˆã•ã‚ŒãŸã¨ãƒžãƒ¼ã‚¯ã§ãã¾ã™ã€‚"
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr "<literal>never</literal> (デフォルト) - 与ãˆã‚‰ã‚ŒãŸãƒ—ãƒãƒ‘ティã®å€¤ã¯ã€ データベースã‹ã‚‰ç”Ÿæˆã•ã‚Œãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr "<literal>insert</literal> - 与ãˆã‚‰ã‚ŒãŸãƒ—ãƒãƒ‘ティã®å€¤ã¯æŒ¿å…¥æ™‚ã«ç”Ÿæˆã•ã‚Œã‚‹ãŒã€ 続ã„ã¦èµ·ã“る更新時ã«ã¯ç”Ÿæˆã•ã‚Œãªã„ã“ã¨ç¤ºã—ã¾ã™ã€‚ 作æˆã•ã‚ŒãŸæ—¥ä»˜ãªã©ã¯ã€ã“ã®ã‚«ãƒ†ã‚´ãƒªã«åˆ†é¡žã•ã‚Œã¾ã™ã€‚ <xref linkend=\"mapping-declaration-version\"/>version ã‚„ <xref linkend=\"mapping-declaration-timestamp\"/>timestamp 㮠プãƒãƒ‘ティã¯ç”Ÿæˆã•ã‚ŒãŸã¨ãƒžãƒ¼ã‚¯ã§ãã¾ã™ãŒã€ã“ã®ã‚ªãƒ—ションã¯åˆ©ç”¨ã§ããªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr "<literal>always</literal> - 挿入時も更新時もプãƒãƒ‘ティã®å€¤ãŒç”Ÿæˆã•ã‚Œã‚‹ã“ã¨ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr "補助的ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ»ã‚ªãƒ–ジェクト"
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr "Hibernateã®ã‚¹ã‚ーマ・エボリューションツールã¨é€£å‹•ã™ã‚‹ã“ã¨ã§ã€ ä»»æ„ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ»ã‚ªãƒ–ジェクト（トリガーやストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ãªã©ï¼‰ã®CREATEã¨DROPã«ã‚ˆã‚Šã€ Hibernateã®ãƒžãƒƒãƒ”ングファイル内ã®ãƒ¦ãƒ¼ã‚¶ãƒ»ã‚¹ã‚ーマをã™ã¹ã¦å®šç¾©ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ 主ã«ãƒˆãƒªã‚¬ã‚„ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ»ã‚ªãƒ–ジェクトを生æˆã‚„削除ã™ã‚‹ã“ã¨ã‚’æ„図ã—ã¦ã„ã¾ã™ãŒã€ 実際ã«ã¯ <literal>java.sql.Statement.execute()</literal> メソッドã«ã‚ˆã£ã¦å®Ÿè¡Œã§ãã‚‹ ä»»æ„ã®SQLコマンド（ALTERã€INSERTãªã©ï¼‰ãŒå®Ÿè¡Œã§ãã¾ã™ã€‚ 補助的ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ»ã‚ªãƒ–ジェクトを定義ã™ã‚‹ãŸã‚ã®ã€2ã¤ã®åŸºæœ¬çš„ãªæ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr "1ã¤ç›®ã®æ–¹æ³•ã¯ã€CREATEã¨DROPコマンドをマッピングファイルã®å¤–ã«ã€æ˜Žç¤ºçš„ã«è¨˜è¼‰ã™ã‚‹ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ " ...
+\n"
+ " <database-object>
+\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>
+\n"
+ " <drop>DROP TRIGGER my_trigger</drop>
+\n"
+ " </database-object>
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr "2ã¤ç›®ã®æ–¹æ³•ã¯ã€CREATEã¨DROPコマンドã®çµ„ã¿ç«‹ã¦æ–¹ã‚’知ã£ã¦ã„るカスタムクラスをæä¾›ã™ã‚‹ã“ã¨ã§ã™ã€‚ ã“ã®ã‚«ã‚¹ã‚¿ãƒ クラス㯠<literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> インタフェースを 実装ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ " ...
+\n"
+ " <database-object>
+\n"
+ " <definition class=\"MyTriggerDefinition\"/>
+\n"
+ " </database-object>
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr "ã•ã‚‰ã«ã€ã‚るデータベース方言ãŒä½¿ç”¨ã•ã‚Œã‚‹æ™‚ã«ã ã‘é©ç”¨ã™ã‚‹ã¨ã„ã£ãŸã‚ˆã†ã«ã€ データベース・オブジェクトãŒä½¿ã‚れるケースをé™å®šã§ãã¾ã™ã€‚"
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ " ...
+\n"
+ " <database-object>
+\n"
+ " <definition class=\"MyTriggerDefinition\"/>
+\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>
+\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>
+\n"
+ " </database-object>
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr ""
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,459 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr "ãƒãƒƒãƒå‡¦ç†"
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr "Hibernateを使ã£ã¦ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«100,000行を挿入ã™ã‚‹æ„šç›´ãªæ–¹æ³•ã¯ã€ã“ã®ã‚ˆã†ãªã‚‚ã®ã§ã™ï¼š"
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "for ( int i=0; i<100000; i++ ) {
+\n"
+ " Customer customer = new Customer(.....);
+\n"
+ " session.save(customer);
+\n"
+ "}
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr "ã“ã‚Œã¯50,000番目ã®è¡Œã®ã‚ãŸã‚Šã§ <literal>OutOfMemoryException</literal> ã§å¤±æ•—ã™ã‚‹ã§ã—ょã†ã€‚ HibernateãŒã‚»ãƒƒã‚·ãƒ§ãƒ³ãƒ¬ãƒ™ãƒ«ã‚ャッシュã§ã€ æ–°ã—ã挿入ã•ã‚ŒãŸã™ã¹ã¦ã® <literal>Customer</literal> インスタンスをã‚ャッシュã™ã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr "ã“ã®ç« ã§ã¯ã€ã“ã®å•é¡Œã‚’回é¿ã™ã‚‹æ–¹æ³•ã‚’紹介ã—ã¾ã™ã€‚ ã—ã‹ã—ãƒãƒƒãƒå‡¦ç†ã‚’ã™ã‚‹ãªã‚‰ã€JDBCãƒãƒƒãƒãŒä½¿ç”¨å¯èƒ½ã§ã‚ã‚‹ã“ã¨ãŒéžå¸¸ã«é‡è¦ã§ã™ã€‚ ãã†ã§ãªã‘ã‚Œã°æ‰‹é ƒãªãƒ‘フォーマンスãŒå¾—られã¾ã›ã‚“。 JDBCãƒãƒƒãƒã‚µã‚¤ã‚ºã‚’æ‰‹é ƒãªæ•°å€¤ï¼ˆä¾‹ãˆã°ã€10ã‹ã‚‰50）ã«è¨å®šã—ã¦ãã ã•ã„："
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr "ã¾ãŸäºŒæ¬¡ã‚ャッシュãŒå…¨ã効ã‹ãªã„プãƒã‚»ã‚¹ã§ã€ ã“ã®ã‚ˆã†ãªä½œæ¥ã‚’ã—ãŸã„ã¨æ€ã†ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“："
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr "ã—ã‹ã—ã€ã“ã‚Œã¯çµ¶å¯¾ã«å¿…è¦ã¨ã„ã†ã‚ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ãªãœãªã‚‰æ˜Žç¤ºçš„ã« <literal>CacheMode</literal> ã‚’è¨å®šã—ã¦ã€ 二次ã‚ャッシュã¨ã®ç›¸äº’作用を無効ã«ã™ã‚‹ã“ã¨ãŒã§ãã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:41
+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 "ãƒãƒƒãƒæŒ¿å…¥"
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr "æ–°ã—ã„オブジェクトを永続化ã™ã‚‹ã¨ãã€ä¸€æ¬¡ã‚ャッシュã®ã‚µã‚¤ã‚ºã‚’制é™ã™ã‚‹ãŸã‚〠セッションを <literal>flush()</literal> ã—㦠<literal>clear()</literal> ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "for ( int i=0; i<100000; i++ ) {
+\n"
+ " Customer customer = new Customer(.....);
+\n"
+ " session.save(customer);
+\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size
+\n"
+ " //flush a batch of inserts and release memory:
+\n"
+ " session.flush();
+\n"
+ " session.clear();
+\n"
+ " }
+\n"
+ "}
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "ãƒãƒƒãƒæ›´æ–°"
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr "データを復元ã—ãŸã‚Šæ›´æ–°ã—ãŸã‚Šã™ã‚‹ã«ã¯åŒã˜ã‚¢ã‚¤ãƒ‡ã‚£ã‚¢ã‚’é©ç”¨ã—ã¾ã™ã€‚ ãã‚Œã«åŠ ãˆã¦ã€ãƒ‡ãƒ¼ã‚¿ã®è¡Œã‚’多ãè¿”ã™ã‚¯ã‚¨ãƒªã«å¯¾ã—ã¦æœ‰åŠ¹ãª サーãƒãƒ¼ã‚µã‚¤ãƒ‰ã®ã‚«ãƒ¼ã‚½ãƒ«ã®åˆ©ç‚¹ã‚’生ã‹ã—ãŸã‘れ㰠<literal>scroll()</literal> を使ã†å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:62
+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 ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")
+\n"
+ " .setCacheMode(CacheMode.IGNORE)
+\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);
+\n"
+ "int count=0;
+\n"
+ "while ( customers.next() ) {
+\n"
+ " Customer customer = (Customer) customers.get(0);
+\n"
+ " customer.updateStuff(...);
+\n"
+ " if ( ++count % 20 == 0 ) {
+\n"
+ " //flush a batch of updates and release memory:
+\n"
+ " session.flush();
+\n"
+ " session.clear();
+\n"
+ " }
+\n"
+ "}
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "StatelessSessionインターフェイス"
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr "ã¾ãŸåˆ¥ã®æ–¹æ³•ã¨ã—ã¦ã€Hibernateã¯ã‚³ãƒžãƒ³ãƒ‰æŒ‡å‘ã®APIを用æ„ã—ã¦ã„ã¾ã™ã€‚ ã“ã‚Œã¯åˆ†é›¢ã‚ªãƒ–ジェクトã®å½¢ã§ã€ データベースã¨ã®ãƒ‡ãƒ¼ã‚¿ã‚¹ãƒˆãƒªãƒ¼ãƒ ã®ã‚„ã‚Šå–ã‚Šã«ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal>StatelessSession</literal> ã¯é–¢é€£ã™ã‚‹æ°¸ç¶šã‚³ãƒ³ãƒ†ã‚ストをæŒãŸãšã€ 高レベルã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã®å¤šãã‚’æä¾›ã—ã¾ã›ã‚“。 特ã«ã‚¹ãƒ†ãƒ¼ãƒˆãƒ¬ã‚¹ã‚»ãƒƒã‚·ãƒ§ãƒ³ã¯ã€ä¸€æ™‚ã‚ャッシュを実装ã›ãšã€ ã¾ãŸã©ã®ã‚ˆã†ãªäºŒæ¬¡ã‚ャッシュやクエリã‚ャッシュã¨ã‚‚相互作用ã—ã¾ã›ã‚“。 トランザクショナルãªwrite-behindや自動ダーティãƒã‚§ãƒƒã‚¯ã‚‚実装ã—ã¾ã›ã‚“。 ステートレスセッションを使ã£ã¦è¡Œã‚れるæ“作ãŒã€ 関連ã™ã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¸ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã•ã‚Œã‚‹ã“ã¨ã¯æ±ºã—ã¦ã‚ã‚Šã¾ã›ã‚“。 コレクションã¯ã€ã‚¹ãƒ†ãƒ¼ãƒˆãƒ¬ã‚¹ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‹ã‚‰ã¯ç„¡è¦–ã•ã‚Œã¾ã™ã€‚ ステートレスセ!
ッションを通ã—ã¦è¡Œã‚れるæ“作ã¯ã€ Hibernateã®ã‚¤ãƒ™ãƒ³ãƒˆãƒ¢ãƒ‡ãƒ«ã‚„インターセプタã®å½±éŸ¿ã‚’å—ã‘ã¾ã›ã‚“。 一時ã‚ャッシュをæŒãŸãªã„ãŸã‚〠ステートレスセッションã¯åˆ¥åã‚’æŒã¤ãƒ‡ãƒ¼ã‚¿ã«ä¸Šæ‰‹ã対処ã§ãã¾ã›ã‚“。 ステートレスセッションã¯ä½Žãƒ¬ãƒ™ãƒ«ã®æŠ½è±¡åŒ–ã§ã‚ã‚Šã€JDBCã«éžå¸¸ã«ã‚ˆãä¼¼ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")
+\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);
+\n"
+ "while ( customers.next() ) {
+\n"
+ " Customer customer = (Customer) customers.get(0);
+\n"
+ " customer.updateStuff(...);
+\n"
+ " session.update(customer);
+\n"
+ "}
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "ã“ã®ã‚³ãƒ¼ãƒ‰ä¾‹ã§ã¯ã€ã‚¯ã‚¨ãƒªãŒè¿”ã™ <literal>Customer</literal> インスタンスã¯å³åº§ã«ï¼ˆã‚»ãƒƒã‚·ãƒ§ãƒ³ã‹ã‚‰ï¼‰åˆ†é›¢ã•ã‚Œã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã‚Œã¯ã€ã©ã®ã‚ˆã†ãªæ°¸ç¶šã‚³ãƒ³ãƒ†ã‚ストã¨ã‚‚決ã—ã¦é–¢é€£ã—ã¾ã›ã‚“。"
+
+#: index.docbook:91
+msgid "Note that 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>StatelessSession</literal> インターフェイスã§å®šç¾©ã•ã‚Œã¦ã„ã‚‹ <literal>insert(), update(), delete()</literal> ã¯ã€ 低レベルã®ç›´æŽ¥çš„ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹æ“作ã¨è€ƒãˆã‚‰ã‚Œã¾ã™ã€‚ çµæžœã¨ã—ã¦ã€SQLã® <literal>INSERT, UPDATE, DELETE</literal> ãŒãã‚Œãžã‚Œå³åº§ã«å®Ÿè¡Œã•ã‚Œã¾ã™ã€‚ ã“ã®ã‚ˆã†ã«ã€ã“れら㯠<literal>Session</literal> インターフェイスã§å®šç¾©ã•ã‚Œã¦ã„ã‚‹ <literal>save(), saveOrUpdate(), delete()</literal> ã¨ã¯éžå¸¸ã«ç•°ãªã‚‹æ„味をæŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr "DMLスタイルã®æ“作"
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr "ã™ã§ã«è°è«–ã—ãŸã‚ˆã†ã«ã€è‡ªå‹•çš„ã‹ã¤é€éŽçš„ãªã‚ªãƒ–ジェクト/リレーショナルマッピングã¯ã€ オブジェクトã®çŠ¶æ…‹ã®ç®¡ç†ã§ã‚ã‚‹ã¨è€ƒãˆã‚‰ã‚Œã¾ã™ã€‚ ã“ã‚Œã¯ãƒ¡ãƒ¢ãƒªå†…ã®ã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã‚’利用ã§ãã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ãã®ãŸã‚（SQLã® <literal>データæ“作言語</literal> (DML) 文： <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal> を使ã£ã¦ï¼‰ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã®ãƒ‡ãƒ¼ã‚¿ã‚’直接æ“作ã—ã¦ã‚‚〠メモリ内ã®çŠ¶æ…‹ã«ã¯å½±éŸ¿ã‚’与ãˆã¾ã›ã‚“。 ã—ã‹ã—Hibernateã¯ã€ãƒãƒ«ã‚¯SQLスタイルã®DML文実行ã«å¯¾å¿œã™ã‚‹ãƒ¡ã‚½ãƒƒãƒ‰ã‚’用æ„ã—ã¦ã„ã¾ã™ã€‚ ã“ã‚Œã¯Hibernateクエリ言語（<xref linkend=\"queryhql\"/>HQL） を通ã—ã¦å®Ÿè¡Œã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr "<literal>UPDATE</literal> 㨠<literal>DELETE</literal> æ–‡ã®ç–‘似構文ã¯ï¼š <literal>( UPDATE | DELETE ) FROM? エンティティå (WHERE æ¡ä»¶ç¯€)?</literal> ã§ã™ã€‚ 注æ„ã™ã¹ã点ãŒã„ãã¤ã‹ã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr "from節ã«ãŠã„ã¦ã€FROMã‚ーワードã¯ã‚ªãƒ—ションã§ã™ã€‚"
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr "from節ã§ã¯å˜ä¸€ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£åã ã‘ãŒå¯èƒ½ã§ã€ ä»»æ„ã§åˆ¥åを付ã‘ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ エンティティåã«åˆ¥åãŒä¸Žãˆã‚‰ã‚Œã‚‹ã¨ã€ã©ã®ã‚ˆã†ãªãƒ—ãƒãƒ‘ティå‚照も〠ãã®åˆ¥åを使ã£ã¦ä¿®é£¾ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã‚‚ã—エンティティåã«åˆ¥åãŒä¸Žãˆã‚‰ã‚Œãªã‘ã‚Œã°ã€ ã©ã®ã‚ˆã†ãªãƒ—ãƒãƒ‘ティå‚照も修飾ã—ã¦ã¯ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 "（暗黙的ã§ã‚れ明示的ã§ã‚れ）<xref linkend=\"queryhql-joins-forms\"/>çµåˆ ã‚’ãƒãƒ«ã‚¯HQLクエリ内ã§æŒ‡å®šã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 サブクエリã¯where節ã§ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ サブクエリãã®ã‚‚ã®ã¯ã€çµåˆã‚’å«ã‚られã¾ã™ã€‚"
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr "where節ã¯ã‚ªãƒ—ションã§ã™ã€‚"
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr "例ã¨ã—ã¦ã€HQLã® <literal>UPDATE</literal> を実行ã™ã‚‹ã«ã¯ã€ <literal>Query.executeUpdate()</literal> メソッドを使ã£ã¦ãã ã•ã„。 （ã“ã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ãŠãªã˜ã¿ã®JDBC <literal>PreparedStatement.executeUpdate()</literal> ã‹ã‚‰å付ã‘られã¾ã—ãŸï¼‰ï¼š d"
+
+#: index.docbook:156
+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 ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";
+\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";
+\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )
+\n"
+ " .setString( \"newName\", newName )
+\n"
+ " .setString( \"oldName\", oldName )
+\n"
+ " .executeUpdate();
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "HQLã® <literal>UPDATE</literal> æ–‡ã¯ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯ã€ä½œç”¨ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã® <xref linkend=\"mapping-declaration-version\"/>version ã‚„ <xref linkend=\"mapping-declaration-timestamp\"/>timestamp プãƒãƒ‘ティã®å€¤ã«ã¯å½±éŸ¿ã—ã¾ã›ã‚“。 ã“ã‚Œã¯EJB3ã®ä»•æ§˜ã«ã‚‚å—ã‘継ãŒã‚Œã¦ã„ã¾ã™ã€‚ ã—ã‹ã— <literal>versioned update</literal> を使ã£ã¦ã€ <literal>version</literal> ã‚„ <literal>timestamp</literal> プãƒãƒ‘ティã®å€¤ã‚’強制的ã«ãƒªã‚»ãƒƒãƒˆã•ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“れ㯠<literal>UPDATE</literal> ã‚ーワードã®å¾Œã« <literal>VERSIONED</literal> ã‚ãƒ¼ãƒ¯ãƒ¼ãƒ‰ã‚’è¿½åŠ ã™ã‚‹ã“ã¨ã§è¡Œãˆã¾ã™ã€‚"
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";
+\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )
+\n"
+ " .setString( \"newName\", newName )
+\n"
+ " .setString( \"oldName\", oldName )
+\n"
+ " .executeUpdate();
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "カスタムãƒãƒ¼ã‚¸ãƒ§ãƒ³åž‹ï¼ˆ<literal>org.hibernate.usertype.UserVersionType</literal>） 㯠<literal>update versioned</literal> æ–‡ã¨ä¸€ç·’ã«ä½¿ãˆãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr "HQLã® <literal>DELETE</literal> を実行ã™ã‚‹ã«ã¯ã€ åŒã˜ <literal>Query.executeUpdate()</literal> メソッドを使ã£ã¦ãã ã•ã„："
+
+#: index.docbook:181
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";
+\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";
+\n"
+ "int deletedEntities = s.createQuery( hqlDelete )
+\n"
+ " .setString( \"oldName\", oldName )
+\n"
+ " .executeUpdate();
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr "<literal>Query.executeUpdate()</literal> メソッドãŒè¿”ã™ <literal>int</literal> ã®å€¤ã¯ã€ã“ã®æ“作ãŒå½±éŸ¿ã‚’åŠã¼ã—ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®æ•°ã§ã™ã€‚ ã“ã‚ŒãŒå½±éŸ¿ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã®è¡Œæ•°ã¨ã€ç›¸äº’ã«é–¢ä¿‚ã™ã‚‹ã‹ã©ã†ã‹ã‚’考ãˆã¦ã¿ã¦ãã ã•ã„。 HQLãƒãƒ«ã‚¯æ“作ã¯ã€çµæžœã¨ã—ã¦ã€å®Ÿéš›ã®SQLæ–‡ãŒè¤‡æ•°å®Ÿè¡Œã•ã‚Œã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ 例ãˆã°joined-subclassã§ã™ã€‚ è¿”ã•ã‚Œã‚‹æ•°ã¯ã€ãã®æ–‡ã«ã‚ˆã£ã¦å½±éŸ¿ã•ã‚ŒãŸå®Ÿéš›ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®æ•°ã‚’示ã—ã¾ã™ã€‚ joined-subclassã®ä¾‹ã«æˆ»ã‚‹ã¨ã€ã‚µãƒ–クラスã®ä¸€ã¤ã«å¯¾ã™ã‚‹å‰Šé™¤ã¯ã€ ãã®ã‚µãƒ–クラスãŒãƒžãƒƒãƒ”ングã•ã‚ŒãŸãƒ†ãƒ¼ãƒ–ルã ã‘ã§ã¯ãªã〠「ルートã€ãƒ†ãƒ¼ãƒ–ルã¨ç¶™æ‰¿éšŽå±¤ã‚’ã•ã‚‰ã«ä¸‹ã£ãŸjoined-subclassã®ãƒ†ãƒ¼ãƒ–ルã®å‰Šé™¤ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr "<literal>INSERT</literal> æ–‡ã®ç–‘似構文ã¯ï¼š <literal>INSERT INTO エンティティå プãƒãƒ‘ティリスト selectæ–‡</literal> ã§ã™ã€‚ 注æ„ã™ã¹ã点ãŒã„ãã¤ã‹ã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr "INSERT INTO ... SELECT ... ã®å½¢å¼ã ã‘ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã™ã€‚ INSERT INTO ... VALUES ... ã®å½¢å¼ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr "プãƒãƒ‘ティリストã¯ã€SQLã® <literal>INSERT</literal> æ–‡ã«ãŠã‘ã‚‹ <literal>カラムã®ä»•æ§˜</literal> ã«é¡žä¼¼ã—ã¦ã„ã¾ã™ã€‚ 継承ã®ãƒžãƒƒãƒ”ングã«å«ã¾ã‚Œã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã—ã¦ã€ クラスレベルã§ç›´æŽ¥å®šç¾©ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã ã‘ãŒã€ãƒ—ãƒãƒ‘ティリストã«ä½¿ãˆã¾ã™ã€‚ スーパークラスã®ãƒ—ãƒãƒ‘ティã¯èªã‚られãšã€ã‚µãƒ–クラスã®ãƒ—ãƒãƒ‘ティã¯åŠ¹æžœãŒã‚ã‚Šã¾ã›ã‚“。 言ã„æ›ãˆã‚‹ã¨ <literal>INSERT</literal> æ–‡ã¯ã€æœ¬è³ªçš„ã«ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 "selectæ–‡ã®è¿”り値ã®åž‹ãŒinsertæ–‡ãŒæœŸå¾…ã™ã‚‹åž‹ã¨ãƒžãƒƒãƒã—ã¦ã„ã‚Œã°ã€ ãã®selectæ–‡ã¯å¦¥å½“ãªHQL selectクエリã¨ãªã‚Šãˆã¾ã™ã€‚ ç¾åœ¨ã“ã®ãƒã‚§ãƒƒã‚¯ã‚’データベースã¸ä»»ã›ã‚‹ã®ã§ã¯ãªãã€ã‚¯ã‚¨ãƒªã®ã‚³ãƒ³ãƒ‘イル時ã«ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚ ã“ã®ã“ã¨ã¯ã€<emphasis>equal</emphasis>ã¨ã¯é•ã„〠Hibernateã® <literal>Type</literal> é–“ã® <emphasis>equivalent</emphasis> ã«é–¢ã™ã‚‹ å•é¡Œã‚’引ãèµ·ã“ã™ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“れ㯠<literal>org.hibernate.type.DataType</literal> ã¨ã—ã¦å®šç¾©ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã¨ã€ <literal>org.hibernate.type.TimestampType</literal> ã¨ã—ã¦å®šç¾©ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã®é–“ã®ãƒŸã‚¹ãƒžãƒƒãƒã®å•é¡Œã‚’引ãèµ·ã“ã—ã¾ã™ã€‚ データベースãŒãれらを区別ã§ããªãã¦ã‚‚ã€å¤‰æ›ã™ã‚‹ã“ã¨ãŒã§ãã¦ã‚‚ã€ã“ã®å•é¡Œã¯ç™ºç”Ÿã—ã¾ã™ã€‚"
+
+#: index.docbook:220
+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. Note however that this might 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 "idプãƒãƒ‘ティã«å¯¾ã—ã¦ã€insertæ–‡ã«ã¯äºŒã¤ã®é¸æŠžè‚¢ãŒã‚ã‚Šã¾ã™ã€‚ プãƒãƒ‘ティリストã§æ˜Žç¤ºçš„ã«idプãƒãƒ‘ティを指定ã™ã‚‹ã‹ （ã“ã®å ´åˆã€å¯¾å¿œã™ã‚‹selectå¼ã‹ã‚‰å€¤ãŒå–られã¾ã™ï¼‰ã€ プãƒãƒ‘ティリストã‹ã‚‰é™¤å¤–ã™ã‚‹ã‹ （ã“ã®å ´åˆã€ç”Ÿæˆã•ã‚Œã‚‹å€¤ãŒä½¿ã‚ã‚Œã¾ã™ï¼‰ã®ã„ãšã‚Œã‹ã§ã™ã€‚ 後者ã®é¸æŠžè‚¢ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã‚’æ“作ã™ã‚‹idジェãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã†ã¨ãã®ã¿ã€åˆ©ç”¨å¯èƒ½ã§ã™ã€‚ ã“ã®é¸æŠžè‚¢ã‚’æŽ¡ã‚‹å ´åˆã€ã€Œã‚¤ãƒ³ãƒ¡ãƒ¢ãƒªã€åž‹ã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã†ã¨ã€æ§‹æ–‡è§£æžæ™‚ã«ä¾‹å¤–ãŒç™ºç”Ÿã—ã¾ã™ã€‚ ã“ã®è°è«–ã§ã¯ã€ã‚¤ãƒ³ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹åž‹ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã¯ <literal>org.hibernate.id.SequenceGenerator</literal> （ã¨ãã®ã‚µãƒ–クラス）ã¨ã€<literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> ã®å®Ÿè£…ã§ã‚ã‚‹ã¨è€ƒãˆã¦ã„ã¾ã™ã€‚ ã“ã“ã§æœ€ã‚‚注æ„ã™ã¹ã例外ã¯ã€<literal>org.hibernate.id.TableHiLoGenerator!
</literal> ã§ã™ã€‚ 値をå–å¾—ã™ã‚‹é¸æŠžå¯èƒ½ãªæ–¹æ³•ãŒãªã„ãŸã‚ã€ã“ã®ã‚¸ã‚§ãƒãƒ¬ãƒ¼ã‚¿ã‚’使ã†ã“ã¨ã¯ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 "<literal>version</literal> ã‚„ <literal>timestamp</literal> ã¨ã—ã¦ãƒžãƒƒãƒ”ングã•ã‚Œã‚‹ãƒ—ãƒãƒ‘ティã«å¯¾ã—ã¦ã€ insertæ–‡ã«ã¯äºŒã¤ã®é¸æŠžè‚¢ãŒã‚ã‚Šã¾ã™ã€‚ プãƒãƒ‘ティリストã§æ˜Žç¤ºçš„ã«ãƒ—ãƒãƒ‘ティを指定ã™ã‚‹ã‹ （ã“ã®å ´åˆã€å¯¾å¿œã™ã‚‹selectå¼ã‹ã‚‰å€¤ãŒå–られã¾ã™ï¼‰ã€ プãƒãƒ‘ティリストã‹ã‚‰é™¤å¤–ã™ã‚‹ã‹ （ã“ã®å ´åˆã€<literal>org.hibernate.type.VersionType</literal> ã§å®šç¾©ã•ã‚ŒãŸ <literal>シード値</literal> ãŒä½¿ã‚ã‚Œã¾ã™ï¼‰ã®ã„ãšã‚Œã‹ã§ã™ã€‚"
+
+#: index.docbook:247
+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 "HQLã® <literal>INSERT</literal> æ–‡ã®å®Ÿè¡Œä¾‹ã§ã™ï¼š"
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";
+\n"
+ "int createdEntities = s.createQuery( hqlInsert )
+\n"
+ " .executeUpdate();
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr "ベストプラクティス"
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr "クラスã¯ç´°ã‹ã„粒度ã§æ›¸ã <literal><component></literal> ã§ãƒžãƒƒãƒ”ングã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr "<literal>street</literal>（通り）, <literal>suburb</literal> （都市）, <literal>state</literal>（州）, <literal>postcode</literal> （郵便番å·ï¼‰ã‚’カプセル化ã™ã‚‹ <literal>Address</literal>（ä½æ‰€ï¼‰ã‚¯ãƒ©ã‚¹ã‚’使ã„ã¾ã—ょã†ã€‚ ãã†ã™ã‚Œã°ã‚³ãƒ¼ãƒ‰ãŒå†åˆ©ç”¨ã—ã‚„ã™ããªã‚Šã€ãƒªãƒ•ã‚¡ã‚¯ã‚¿ãƒªãƒ³ã‚°ã‚‚ç°¡å˜ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr "永続クラスã«ã¯è˜åˆ¥åプãƒãƒ‘ティを定義ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr "Hibernateã§ã¯è˜åˆ¥åプãƒãƒ‘ティã¯ã‚ªãƒ—ションã§ã™ãŒã€ 使用ã™ã¹ãç†ç”±ãŒãŸãã•ã‚“ã‚ã‚Šã¾ã™ã€‚ è˜åˆ¥åã¯ã€Œäººå·¥çš„ã€ï¼ˆç”Ÿæˆã•ã‚ŒãŸã€æ¥å‹™çš„ãªæ„味をæŒãŸãªã„） ãªã‚‚ã®ã«ã™ã‚‹ã“ã¨ã‚’ãŠã™ã™ã‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr "自然ã‚ーを見ã¤ã‘ã¾ã—ょã†ã€‚"
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr "ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã—ã¦è‡ªç„¶ã‚ーを見ã¤ã‘ã¦ã€ <literal><natural-id></literal> ã§ãƒžãƒƒãƒ”ングã—ã¾ã—ょã†ã€‚ 自然ã‚ーを構æˆã™ã‚‹ãƒ—ãƒãƒ‘ティを比較ã™ã‚‹ãŸã‚ã«ã€ <literal>equals()</literal> 㨠<literal>hashCode()</literal> を実装ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr "クラスã®ãƒžãƒƒãƒ”ングã¯ãã‚Œãžã‚Œã®ã‚¯ãƒ©ã‚¹å°‚用ã®ãƒ•ã‚¡ã‚¤ãƒ«ã«æ›¸ãã¾ã—ょã†ã€‚"
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr "å˜ä¸€ã®å·¨å¤§ãªãƒžãƒƒãƒ”ングドã‚ュメントを使用ã—ãªã„ã§ãã ã•ã„。 <literal>com.eg.Foo</literal> クラスãªã‚‰ <literal>com/eg/Foo.hbm.xml</literal> ファイルã«ãƒžãƒƒãƒ”ングã—ã¾ã—ょã†ã€‚ ã“ã®ã“ã¨ã¯ã€ç‰¹ã«ãƒãƒ¼ãƒ ã§ã®é–‹ç™ºã«æ„味ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr "リソースã¨ã—ã¦ãƒžãƒƒãƒ”ングをãƒãƒ¼ãƒ‰ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr "マッピングをã€ãれらãŒãƒžãƒƒãƒ”ングã™ã‚‹ã™ã‚‹ã‚¯ãƒ©ã‚¹ã¨ä¸€ç·’ã«é…ç½®ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr "クエリ文å—列を外部ã«ç½®ãã“ã¨ã‚’考ãˆã¾ã—ょã†"
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr "クエリãŒANSI標準ã§ãªã„SQL関数を呼んã§ã„ã‚‹ãªã‚‰ã€ã“ã‚Œã¯ã‚ˆã„プラクティスã§ã™ã€‚ クエリ文å—列をマッピングファイルã¸å¤–出ã—ã™ã‚Œã°ã‚¢ãƒ—リケーションãŒãƒãƒ¼ã‚¿ãƒ–ルã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr "ãƒã‚¤ãƒ³ãƒ‰å¤‰æ•°ã‚’使ã„ã¾ã—ょã†ã€‚"
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr "JDBCã®å ´åˆã¨åŒã˜ã‚ˆã†ã«ã€å®šæ•°ã§ãªã„値ã¯å¿…ãš\"?\"ã§ç½®ãæ›ãˆã¾ã—ょã†ã€‚ 定数ã§ãªã„値をãƒã‚¤ãƒ³ãƒ‰ã™ã‚‹ãŸã‚ã«ã€ã‚¯ã‚¨ãƒªã§æ–‡å—列æ“作を使ã£ã¦ã¯ã„ã‘ã¾ã›ã‚“。 åå‰ä»˜ãã®ãƒ‘ラメータを使ã†ã‚ˆã†ã«ã™ã‚‹ã¨ã•ã‚‰ã«è‰¯ã„ã§ã™ã€‚"
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr "JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’管ç†ã—ã¦ã¯ã„ã‘ã¾ã›ã‚“。"
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr "Hibernateã§ã¯ã‚¢ãƒ—リケーションãŒJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’管ç†ã™ã‚‹ã“ã¨ãŒè¨±ã•ã‚Œã¦ã„ã¾ã™ã€‚ ã—ã‹ã—ã“ã‚Œã¯æœ€çµ‚手段ã ã¨æ€ã£ã¦ãã ã•ã„。 組ã¿è¾¼ã¿ã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ãƒãƒã‚¤ãƒ€ã‚’使ã†ã“ã¨ãŒã§ããªã‘ã‚Œã°ã€ <literal>org.hibernate.connection.ConnectionProvider</literal> を実装ã™ã‚‹ã“ã¨ã‚’考ãˆã¦ãã ã•ã„。"
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr "カスタム型ã®ä½¿ç”¨ã‚’考ãˆã¾ã—ょã†ã€‚"
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr "ã‚るライブラリã‹ã‚‰æŒã£ã¦ããŸJava型を永続化ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã¨ã—ã¾ã—ょã†ã€‚ ã—ã‹ã—ãã®åž‹ã«ã¯ã€ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¨ã—ã¦ãƒžãƒƒãƒ”ングã™ã‚‹ãŸã‚ã«å¿…è¦ãªã‚¢ã‚¯ã‚»ã‚µãŒãªã„ã¨ã—ã¾ã™ã€‚ ã“ã®ã‚ˆã†ãªå ´åˆã¯ <literal>org.hibernate.UserType</literal> ã®å®Ÿè£…を考ãˆã‚‹ã¹ãã§ã™ã€‚ ãã†ã™ã‚Œã°Hibernateåž‹ã¨ã®å®Ÿè£…変æ›ã‚’心é…ã›ãšã«ã‚¢ãƒ—リケーションã®ã‚³ãƒ¼ãƒ‰ã‚’扱ãˆã¾ã™ã€‚"
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr "ボトルãƒãƒƒã‚¯ã‚’解消ã™ã‚‹ã«ã¯JDBCã‚’ãƒãƒ³ãƒ‰ã‚³ãƒ¼ãƒ‰ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr "システムã®ãƒ‘フォーマンスクリティカルãªé ˜åŸŸã§ã¯ã€ ã‚る種ã®æ“作ã«JDBCを直接使ã†ã¨è‰¯ã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã—ã‹ã—何ãŒãƒœãƒˆãƒ«ãƒãƒƒã‚¯ã«ãªã£ã¦ã„ã‚‹ã‹ <emphasis>ã¯ã£ãã‚Šã™ã‚‹</emphasis> ã¾ã§ã¯å¾…ã£ã¦ãã ã•ã„。 ã¾ãŸJDBCを直接使ã†ã‹ã‚‰ã¨ã„ã£ã¦ã€å¿…ãšã—も速ããªã‚‹ã¨ã¯é™ã‚‰ãªã„ã“ã¨ã‚‚ç†è§£ã—ã¦ãã ã•ã„。 JDBCを直接使ã†å¿…è¦ãŒã‚ã‚Œã°ã€Hibernateã® <literal>Session</literal> をオープンã—ã¦ã€ JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã†ã¨è‰¯ã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ä¾ç„¶ã¨ã—ã¦åŒã˜ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³æˆ¦ç•¥ã¨ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ãƒãƒã‚¤ãƒ€ãŒä½¿ãˆã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr "<literal>Session</literal> ã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã‚’ç†è§£ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr "SessionãŒæ°¸ç¶šçŠ¶æ…‹ã‚’データベースã¨åŒæœŸã•ã›ã‚‹ã“ã¨ãŒã¨ãã©ãã‚ã‚Šã¾ã™ã€‚ ã—ã‹ã—ã“ã‚ŒãŒã‚ã¾ã‚Šã«é »ç¹ã«èµ·ã“るよã†ã ã¨ã€ãƒ‘フォーマンスã«å½±éŸ¿ãŒå‡ºã¦ãã¾ã™ã€‚ 自動フラッシュを無効ã«ã—ãŸã‚Šã€ç‰¹å®šã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚¯ã‚¨ãƒªã‚„æ“作ã®é †ç•ªã‚’変更ã™ã‚‹ã“ã¨ã§ã€ ä¸å¿…è¦ãªãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã‚’最å°é™ã«ã§ãã¾ã™ã€‚"
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr "3層アーã‚テクãƒãƒ£ã§ã¯åˆ†é›¢ã‚ªãƒ–ジェクトã®ä½¿ç”¨ã‚’考ãˆã¾ã—ょã†ã€‚"
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr "サーブレット / セッションビーンアーã‚テクãƒãƒ£ã‚’使ã†ã¨ã〠サーブレット層 / JSP層間ã§ã‚»ãƒƒã‚·ãƒ§ãƒ³ãƒ“ーンã§ãƒãƒ¼ãƒ‰ã—ãŸæ°¸ç¶šã‚ªãƒ–ジェクトをやりå–ã‚Šã§ãã¾ã™ã€‚ ãã®éš›ãƒªã‚¯ã‚¨ã‚¹ãƒˆã”ã¨ã«æ–°ã—ã„Sessionを使ã£ã¦ãã ã•ã„。 ã¾ãŸ <literal>Session.merge()</literal> ã‚„ <literal>Session.saveOrUpdate()</literal> を使ã£ã¦ã€ã‚ªãƒ–ジェクトã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’åŒæœŸã•ã›ã¦ãã ã•ã„。"
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr "2層アーã‚テクãƒãƒ£ã§ã¯é•·ã„永続コンテã‚ストã®ä½¿ç”¨ã‚’考ãˆã¾ã—ょã†ã€‚"
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr "最高ã®ã‚¹ã‚±ãƒ¼ãƒ©ãƒ“リティを得るã«ã¯ã€ データベーストランザクションをã§ãã‚‹ã ã‘çŸãã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã—ã‹ã—é•·ã„間実行ã™ã‚‹ <emphasis>アプリケーショントランザクション</emphasis> ã®å®Ÿè£…ãŒå¿…è¦ãªã“ã¨ã¯ã—ã°ã—ã°ã§ã™ã€‚ ã“ã‚Œã¯ãƒ¦ãƒ¼ã‚¶ã®è¦–点ã‹ã‚‰ã¯1個ã®ä½œæ¥å˜ä½ï¼ˆunit of work）ã«ãªã‚Šã¾ã™ã€‚ アプリケーショントランザクションã¯ã„ãã¤ã‹ã®ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆã®ãƒªã‚¯ã‚¨ã‚¹ãƒˆ/レスãƒãƒ³ã‚¹ã‚µã‚¤ã‚¯ãƒ«ã«ã¾ãŸãŒã‚Šã¾ã™ã€‚ アプリケーショントランザクションã®å®Ÿè£…ã«åˆ†é›¢ã‚ªãƒ–ジェクトを使ã†ã®ã¯ä¸€èˆ¬çš„ã§ã™ã€‚ ãã†ã§ãªã‘ã‚Œã°ã€2層アーã‚テクãƒãƒ£ã®å ´åˆã¯ç‰¹ã«é©åˆ‡ãªã“ã¨ã§ã™ãŒã€ アプリケーショントランザクションã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«å…¨ä½“ã«å¯¾ã—㦠å˜ä¸€ã®ã‚ªãƒ¼ãƒ—ンãªæ°¸ç¶šåŒ–コンテã‚スト（セッション）をç¶æŒã—ã¦ãã ã•ã„。 ãã—ã¦å˜ç´”ã«ãƒª!
クエストã®æœ€å¾Œã«JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‹ã‚‰åˆ‡æ–ã—〠次ã®ãƒªã‚¯ã‚¨ã‚¹ãƒˆã®æœ€åˆã«å†æŽ¥ç¶šã—ã¾ã™ã€‚ 決ã—ã¦è¤‡æ•°ã®ã‚¢ãƒ—リケーショントランザクションユースケースã«æ¸¡ã£ã¦ 1個ã®Sessionを使ã„回ã•ãªã„ã§ãã ã•ã„。 ãã†ã§ãªã‘ã‚Œã°ã€å¤ã„データã§ä½œæ¥ã™ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr "例外を復帰å¯èƒ½ãªã‚‚ã®ã¨ã—ã¦æ‰±ã£ã¦ã¯ã„ã‘ã¾ã›ã‚“。"
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr "ã“ã‚Œã¯ã€Œãƒ™ã‚¹ãƒˆã€ãƒ—ラクティス以上ã®ã€å¿…é ˆã®ãƒ—ラクティスã§ã™ã€‚ 例外ãŒç™ºç”Ÿã—ãŸã¨ã㯠<literal>Transaction</literal> ã‚’ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—ã¦ã€ <literal>Session</literal> をクãƒãƒ¼ã‚ºã—ã¦ãã ã•ã„。 ãã†ã—ãªã„ã¨Hibernateã¯ãƒ¡ãƒ¢ãƒªã®çŠ¶æ…‹ãŒæ°¸ç¶šçŠ¶æ…‹ã‚’æ£ç¢ºã«è¡¨ç¾ã—ã¦ã„ã‚‹ã“ã¨ã‚’ä¿è¨¼ã§ãã¾ã›ã‚“。 ã“ã®ç‰¹åˆ¥ãªå ´åˆã¨ã—ã¦ã€ä¸Žãˆã‚‰ã‚ŒãŸè˜åˆ¥åã‚’æŒã¤ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«å˜åœ¨ã™ã‚‹ã‹ã©ã†ã‹ã‚’判定ã™ã‚‹ãŸã‚ã«ã€ <literal>Session.load()</literal> を使ã†ã“ã¨ã¯ã‚„ã‚ã¦ãã ã•ã„。 ãã®ä»£ã‚ã‚Šã« <literal>Session.get()</literal> ã‹ã‚¯ã‚¨ãƒªã‚’使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr "関連ã«ã¯ãªã‚‹ã¹ãé…延フェッãƒã‚’使ã„ã¾ã—ょã†ã€‚"
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr "å³æ™‚フェッãƒã¯æŽ§ãˆã‚ã«ã—ã¾ã—ょã†ã€‚ 二次ã‚ャッシュã«ã¯å®Œå…¨ã«ä¿æŒã•ã‚Œãªã„よã†ãªã‚¯ãƒ©ã‚¹ã®é–¢é€£ã«ã¯ã€ プãƒã‚ã‚·ã¨é…延コレクションを使ã£ã¦ãã ã•ã„。 ã‚ャッシュã•ã‚Œã‚‹ã‚¯ãƒ©ã‚¹ã®é–¢é€£ã€ã¤ã¾ã‚Šã‚ャッシュãŒãƒ’ットã™ã‚‹å¯èƒ½æ€§ãŒéžå¸¸ã«é«˜ã„関連ã¯ã€ <literal>lazy=\"false\"</literal> ã§ç©æ¥µçš„ãªãƒ•ã‚§ãƒƒãƒã‚’明示的ã«ç„¡åŠ¹ã«ã—ã¦ãã ã•ã„。 çµåˆãƒ•ã‚§ãƒƒãƒãŒé©åˆ‡ãªç‰¹å®šã®ãƒ¦ãƒ¼ã‚¹ã‚±ãƒ¼ã‚¹ã«ã¯ã€ クエリ㧠<literal>left join fetch</literal> を使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr "フェッãƒã•ã‚Œã¦ã„ãªã„データã«é–¢ã‚ã‚‹å•é¡Œã‚’é¿ã‘ã‚‹ãŸã‚ã«ã€ <emphasis>ビューã®ä¸ã§ã‚ªãƒ¼ãƒ—ンセッションを使ã†(open session in view)</emphasis> パターンã‹ã€çµ±åˆ¶ã•ã‚ŒãŸ <emphasis>組ã¿ç«‹ã¦ãƒ•ã‚§ãƒ¼ã‚º(assembly phase)</emphasis> を使ã„ã¾ã—ょã†ã€‚"
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr "Hibernate㯠<emphasis>Data Transfer Objects</emphasis> (DTO)を書ã退屈ãªä½œæ¥ã‹ã‚‰é–‹ç™ºè€…を解放ã—ã¾ã™ã€‚ ä¼çµ±çš„ãªEJBアーã‚テクãƒãƒ£ã§ã¯DTOã¯äºŒã¤ç›®çš„ãŒã‚ã‚Šã¾ã™ï¼š 1ã¤ç›®ã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒ“ーンãŒã‚·ãƒªã‚¢ãƒ©ã‚¤ã‚ºã•ã‚Œãªã„å•é¡Œã¸ã®å¯¾ç–ã§ã™ã€‚ 2ã¤ç›®ã¯ã€ãƒ—レゼンテーション層ã«åˆ¶å¾¡ãŒæˆ»ã‚‹å‰ã«ã€ ビューã«ä½¿ã‚れるã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ãŒãƒ•ã‚§ãƒƒãƒã•ã‚Œã¦ã€DTOã«å¾©å…ƒã•ã‚Œã‚‹ã‚ˆã†ãªçµ„ã¿ç«‹ã¦ãƒ•ã‚§ãƒ¼ã‚ºã‚’暗黙的ã«å®šç¾©ã—ã¾ã™ã€‚ Hibernateã§ã¯1ã¤ç›®ã®ç›®çš„ãŒä¸è¦ã«ãªã‚Šã¾ã™ã€‚ ã—ã‹ã—ビューã®ãƒ¬ãƒ³ãƒ€ãƒªãƒ³ã‚°å‡¦ç†ã®é–“ã€æ°¸ç¶šã‚³ãƒ³ãƒ†ã‚スト（セッション）をオープンã«ã—ãŸã¾ã¾ã«ã—ãªã‘ã‚Œã°ã€ 組ã¿ç«‹ã¦ãƒ•ã‚§ãƒ¼ã‚ºã¯ã¾ã å¿…è¦ã§ã™ï¼ˆåˆ†é›¢ã‚ªãƒ–ジェクトã®ä¸ã®ã©ã®ãƒ‡ãƒ¼ã‚¿ãŒåˆ©ç”¨å¯èƒ½ã‹ã«ã¤ã„ã¦ã€ プレゼンテーション層ã¨åŽ³å¯†ãªå–り決ã‚ã‚’ã—ã¦ã„るビジãƒã‚¹ãƒ¡ã‚½ãƒƒãƒ‰ã‚’考ãˆã¦ã!
¿ã¦ãã ã•ã„）。 ã“ã‚Œã¯Hibernateå´ã®å•é¡Œã§ã¯ã‚ã‚Šã¾ã›ã‚“。 トランザクション内ã§å®‰å…¨ã«ãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã®åŸºæœ¬çš„ãªè¦ä»¶ã§ã™ã€‚"
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr "Hibernateã‹ã‚‰ãƒ“ジãƒã‚¹ãƒã‚¸ãƒƒã‚¯ã‚’抽象化ã™ã‚‹ã“ã¨ã‚’考ãˆã¾ã—ょã†ã€‚"
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr "インターフェイスã§ï¼ˆHibernateã®ï¼‰ãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹ã‚³ãƒ¼ãƒ‰ã‚’éš è”½ã—ã¾ã—ょã†ã€‚ <emphasis>DAO</emphasis> 㨠<emphasis>Thread Local Session</emphasis> パターンを組ã¿åˆã‚ã›ã¾ã—ょã†ã€‚ <literal>UserType</literal> ã§Hibernateã«é–¢é€£ä»˜ã‘ã‚‹ã¨ã€ ãƒãƒ³ãƒ‰ã‚³ãƒ¼ãƒ‰ã—ãŸJDBCã§æ°¸ç¶šåŒ–ã™ã‚‹ã‚¯ãƒ©ã‚¹ã‚’æŒã¤ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ （ã“ã®ã‚¢ãƒ‰ãƒã‚¤ã‚¹ã¯ã€Œå分大ããªã€ã‚¢ãƒ—リケーションã«å¯¾ã—ã¦ã®ã‚‚ã®ã§ã™ã€‚ テーブルãŒ5個ã—ã‹ãªã„よã†ãªã‚¢ãƒ—リケーションã«ã¯å½“ã¦ã¯ã¾ã‚Šã¾ã›ã‚“。）"
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr "çã—ã„関連マッピングã¯ä½¿ã‚ãªã„よã†ã«ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr "よã„ユースケースã«æœ¬å½“ã®å¤šå¯¾å¤šé–¢é€£ãŒã‚ã‚‹ã“ã¨ã¯ç¨€ï¼ˆã¾ã‚Œï¼‰ã§ã™ã€‚ ã»ã¨ã‚“ã©ã®å ´åˆã€Œãƒªãƒ³ã‚¯ãƒ†ãƒ¼ãƒ–ルã€ã®ä»˜åŠ çš„ãªæƒ…å ±ãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚ ã“ã®å ´åˆã€ãƒªãƒ³ã‚¯ã‚¯ãƒ©ã‚¹ã«2ã¤ã®1対多関連を使ã†æ–¹ãŒãšã£ã¨è‰¯ã„ã§ã™ã€‚ 実際ã»ã¨ã‚“ã©ã®å ´åˆé–¢é€£ã¯1対多ã¨å¤šå¯¾1ãªã®ã§ã€ ä»–ã®ã‚¹ã‚¿ã‚¤ãƒ«ã®é–¢é€£ã‚’使ã†ã¨ãã¯æœ¬å½“ã«å¿…è¦ã‹ã©ã†ã‹ã‚’考ãˆã¦ã¿ã¦ãã ã•ã„。"
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr "ãªã‚‹ã¹ãåŒæ–¹å‘関連ã«ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr "å˜æ–¹å‘関連ã¯åŒæ–¹å‘ã«æ¯”ã¹ã¦æ¤œç´¢ãŒé›£ã—ããªã‚Šã¾ã™ã€‚ 大ããªã‚¢ãƒ—リケーションã§ã¯ã€ ã»ã¨ã‚“ã©ã™ã¹ã¦ã®é–¢é€£ãŒåŒæ–¹å‘ã«ãƒŠãƒ“ゲーションã§ããªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1287 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr "コレクションã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr "コレクションã®æ°¸ç¶šåŒ–"
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr "コレクション型ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã‚’永続化ã™ã‚‹ã«ã¯ã€ ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³åž‹ãŒã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹åž‹ã§ã‚ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ 例ãˆã°ã€"
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr "実在ã™ã‚‹ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã«ã¯ <literal>java.util.Set</literal>〠<literal>java.util.Collection</literal>ã€<literal>java.util.List</literal>〠<literal>java.util.Map</literal>ã€<literal>java.util.SortedSet</literal>〠<literal>java.util.SortedMap</literal> ãªã©ãŒã‚ã‚Šã¾ã™ã€‚ ã¾ãŸã¯ã€ä»»æ„ã®ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ãŒä½¿ãˆã¾ã™ï¼ （ãŸã ã—ã€ä»»æ„ã®ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’使用ã™ã‚‹å ´åˆã¯ã€ <literal>org.hibernate.usertype.UserCollectionType</literal> ã®å®Ÿè£…クラスを作æˆã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚）"
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr "<literal>HashSet</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’æŒã¤ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ãŒ ã©ã®ã‚ˆã†ã«åˆæœŸåŒ–ã•ã‚Œã‚‹ã‹ã«æ³¨ç›®ã—ã¦ã¿ã¾ã—ょã†ã€‚ ã“ã‚Œã¯æ–°ãŸã«ç”Ÿæˆã•ã‚ŒãŸï¼ˆæ°¸ç¶šåŒ–ã•ã‚Œã¦ã„ãªã„）コレクション型ã®ãƒ—ãƒãƒ‘ティを åˆæœŸåŒ–ã™ã‚‹æœ€é©ãªæ–¹æ³•ã§ã™ã€‚ （例ãˆã° <literal>persist()</literal> ã«ã‚ˆã‚Šï¼‰ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’永続化ã—よã†ã¨ã—ãŸã¨ã〠Hibernate㯠<literal>HashSet</literal> ã‚’Hibernate独自㮠<literal>Set</literal> ã®å®Ÿè£…クラスã«ç½®ãæ›ãˆã¾ã™ã€‚ ã“ã®ãŸã‚ã€æ¬¡ã®ã‚ˆã†ãªã‚¨ãƒ©ãƒ¼ã«ã¯æ³¨æ„ãŒå¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr "Hibernateã«ã‚ˆã‚Šæ³¨å…¥ã•ã‚ŒãŸæ°¸ç¶šæ€§ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ã€ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹åž‹ã«å¿œã˜ã¦ã€ <literal>HashMap</literal> ã‚„ <literal>HashSet</literal>〠<literal>TreeMap</literal>〠<literal>TreeSet</literal>〠<literal>ArrayList</literal> ã®ã‚ˆã†ã«æŒ¯èˆžã„ã¾ã™ã€‚"
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr "コレクションインスタンスã¯ã€å€¤åž‹ã¨ã—ã¦æ™®é€šã«æŒ¯èˆžã„ã¾ã™ã€‚ 永続化オブジェクトã«å‚ç…§ã•ã‚ŒãŸã¨ãã«è‡ªå‹•çš„ã«æ°¸ç¶šåŒ–ã•ã‚Œã€ å‚ç…§ãŒãªããªã£ãŸã¨ãã«è‡ªå‹•çš„ã«å‰Šé™¤ã•ã‚Œã¾ã™ã€‚ ã‚‚ã—ã‚る永続化オブジェクトã‹ã‚‰åˆ¥ã®æ°¸ç¶šåŒ–オブジェクトã«æ¸¡ã•ã‚ŒãŸã‚‰ã€ ãã®è¦ç´ ã¯ç¾åœ¨ã®ãƒ†ãƒ¼ãƒ–ルã‹ã‚‰åˆ¥ã®ãƒ†ãƒ¼ãƒ–ルã«ç§»å‹•ã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ï¼’ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒåŒã˜ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’共有ã—ã¦ã¯ã„ã‘ã¾ã›ã‚“。 リレーショナルモデルをベースã«ã—ã¦ã„ã‚‹ãŸã‚ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³åž‹ã®ãƒ—ãƒãƒ‘ティ㫠null値を代入ã—ã¦ã‚‚æ„味ãŒã‚ã‚Šã¾ã›ã‚“。 ã¤ã¾ã‚ŠHibernateã¯å‚照先ã®ãªã„コレクションã¨ç©ºã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’区別ã—ã¾ã›ã‚“。"
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr "ã—ã‹ã—ãã‚Œã»ã©å¿ƒé…ã—ãªãã¦ã‚‚構ã„ã¾ã›ã‚“。 普段使ã£ã¦ã„ã‚‹Javaã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¨åŒã˜ã‚ˆã†ã«ã€æ°¸ç¶šåŒ–コレクションを使ã£ã¦ãã ã•ã„。 åŒæ–¹å‘関連ã®æ„味をç†è§£ã™ã‚Œã°ã‚ˆã„ã®ã§ã™ï¼ˆã“ã‚Œã¯å¾Œã»ã©èª¬æ˜Žã—ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr "コレクションã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr "コレクションをマッピングã™ã‚‹ãŸã‚ã®ãƒžãƒƒãƒ”ングè¦ç´ ã¯ã€ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã®åž‹ã«ä¾å˜ã—ã¾ã™ã€‚ 例ãˆã°ã€<literal><set></literal> è¦ç´ 㯠<literal>Set</literal> åž‹ã‚’ マッピングã™ã‚‹ãŸã‚ã«ä½¿ã„ã¾ã™ã€‚"
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr "マッピングè¦ç´ ã«ã¯ <literal><set></literal> ã®ä»–ã« <literal><list></literal>〠<literal><map></literal>ã€<literal><bag></literal>〠<literal><array></literal>ã€<literal><primitive-array></literal> ãŒã‚ã‚Šã¾ã™ã€‚ 代表ã¨ã—ã¦ã€<literal><map></literal> è¦ç´ を下記ã«ç¤ºã—ã¾ã™ã€‚"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr "<literal>name</literal> コレクション型ã§ã‚るプãƒãƒ‘ティã®åå‰"
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr "<literal>table</literal> （オプション - デフォルトã¯ãƒ—ãƒãƒ‘ティå）コレクションテーブルã®åå‰ ï¼ˆä¸€å¯¾å¤šé–¢é€£ã§ã¯ä½¿ç”¨ã—ã¾ã›ã‚“）。"
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr "<literal>schema</literal> （オプション）テーブルスã‚ーマã®åå‰ã€‚ ルートè¦ç´ ã§å®£è¨€ã•ã‚Œã¦ã„るスã‚ーマより優先ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr "<literal>lazy</literal> （オプション - デフォルト㯠<literal>true</literal>） é…延フェッãƒã‚’無効ã«ã—ã€é–¢é€£ã‚’常ã«å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã«ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã—ã¾ã™ã€‚ ã¾ãŸã¯ã€ã€Œextra-lazyã€ãƒ•ã‚§ãƒƒãƒã‚’有効ã«ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã—ã¾ã™ã€‚ 「extra-lazyã€ãƒ•ã‚§ãƒƒãƒã¯ã€ã»ã¨ã‚“ã©ã®æ“作ã§ã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’åˆæœŸåŒ–ã—ã¾ã›ã‚“ （éžå¸¸ã«å¤§ããªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«é©ã—ã¦ã„ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr "<literal>inverse</literal> （オプション - デフォルト㯠<literal>false</literal>） ã“ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãŒåŒæ–¹å‘関連ã®ã€Œé€†ã€å´ã§ã‚ã‚‹ã¨ãƒžãƒ¼ã‚¯ã—ã¾ã™ã€‚"
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr "<literal>cascade</literal> （オプション - デフォルト㯠<literal>none</literal>） åエンティティã¸ã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰æ“作を有効ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr "<literal>sort</literal> （オプション）コレクションを自然ãªé †åºã§ã‚½ãƒ¼ãƒˆã™ã‚‹å ´åˆã¯ <literal>natural</literal> を指定ã—ã¾ã™ã€‚ ã‚ã‚‹ã„ã¯Comparatorクラスを指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr "<literal>order-by</literal> （オプションã€JDK1.4ã®ã¿ï¼‰ <literal>Map</literal>ã€<literal>Set</literal>ã€bagã®ã‚¤ãƒ†ãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³é †åºã‚’定義ã™ã‚‹ テーブルカラムを指定ã™ã‚‹ã¨å…±ã«ã€ オプションã¨ã—㦠<literal>asc</literal>ã€<literal>desc</literal> を指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr "<literal>where</literal> （オプション）コレクションã®æ¤œç´¢ã‚„削除ã®éš›ã«ä½¿ã† ä»»æ„ã®SQLã®<literal>WHERE</literal> æ¡ä»¶ã‚’指定ã—ã¾ã™ （利用å¯èƒ½ãªãƒ‡ãƒ¼ã‚¿ã®ä¸€éƒ¨åˆ†ã ã‘をコレクションãŒå«ã‚€ã¹ãã¨ãã«ã€ã“ã‚Œã¯æœ‰ç”¨ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr "<literal>fetch</literal>（オプション - デフォルト㯠<literal>select</literal>） 外部çµåˆã«ã‚ˆã‚‹ãƒ•ã‚§ãƒƒãƒã€é †æ¬¡é¸æŠžãƒ•ã‚§ãƒƒãƒï¼ˆsequential select fetchï¼‰ã€ é †æ¬¡ã‚µãƒ–ã‚»ãƒ¬ã‚¯ãƒˆãƒ•ã‚§ãƒƒãƒï¼ˆsequential subselect fetch）ã®ã©ã‚Œã‹ã‚’é¸æŠžã—ã¦ãã ã•ã„。"
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr "<literal>batch-size</literal> （オプション - デフォルト㯠<literal>1</literal>） コレクションã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®é…延フェッãƒã®ãŸã‚ã®ã€Œãƒãƒƒãƒã‚µã‚¤ã‚ºã€ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr "<literal>access</literal> （オプション - デフォルト㯠<literal>property</literal>） コレクション型プãƒãƒ‘ティã®å€¤ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã™ã‚‹æˆ¦ç•¥ã§ã™ã€‚"
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr "<literal>optimistic-lock</literal>（オプション - デフォルト㯠<literal>true</literal>） コレクションã®çŠ¶æ…‹ã‚’変ãˆã‚‹ã“ã¨ã«ã‚ˆã£ã¦ã€ ãã®ã‚ªãƒ¼ãƒŠãƒ¼ã§ã‚るエンティティã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãŒã‚¤ãƒ³ã‚¯ãƒªãƒ¡ãƒ³ãƒˆã•ã‚Œã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚ （一対多関連ã§ã¯ã€ã»ã¨ã‚“ã©ã®å ´åˆã«ãŠã„ã¦ç„¡åŠ¹ã«è¨å®šã™ã‚‹ã®ãŒå¦¥å½“ã§ã™ã€‚）"
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr "<literal>mutable</literal>（オプション - デフォルト㯠<literal>true</literal>） <literal>false</literal> 値ã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ãŒå¤‰æ›´ã•ã‚Œãªã„ã“ã¨ã‚’表ã—ã¾ã™ （ã‚ã‚‹å ´åˆã«ã¯ã€å°‘ã—パフォーマンスを高ã‚ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr "コレクションã®å¤–部ã‚ー"
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr "コレクションã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã§ã¯ã€ ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’所有ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å¤–部ã‚ーã«ã‚ˆã£ã¦è˜åˆ¥ã•ã‚Œã¾ã™ã€‚ ã“ã®å¤–部ã‚ーã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒ†ãƒ¼ãƒ–ル㮠<emphasis>コレクションã‚ーカラム</emphasis> ã¨å‘¼ã°ã‚Œã¾ã™ã€‚ コレクションã‚ーカラム㯠<literal><key></literal> è¦ç´ ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚"
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr "外部ã‚ーカラムã«ã¯nullè¨å®šåˆ¶ç´„ãŒã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã»ã¨ã‚“ã©ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å½“ã¦ã¯ã¾ã‚‹ã§ã—ょã†ã€‚ å˜æ–¹å‘ã®ä¸€å¯¾å¤šé–¢é€£ã«ãŠã„ã¦ã€å¤–部ã‚ーカラムã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§nullを許ã™è¨å®šã«ãªã£ã¦ã„ã¾ã™ã€‚ よã£ã¦ã€<literal>not-null=\"true\"</literal> を指定ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr "外部ã‚ーã®åˆ¶ç´„㌠<literal>ON DELETE CASCADE</literal> を使ã†ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr "<literal><key></literal> è¦ç´ ã®ã™ã¹ã¦ã®å®šç¾©ã«ã¤ã„ã¦ã¯å‰ã®ç« ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr "コレクションã®è¦ç´ "
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr "コレクションã¯ä»–ã®Hibernateã®åž‹ã®ã»ã¨ã‚“ã©ï¼ˆã™ã¹ã¦ã®åŸºæœ¬åž‹ã€ã‚«ã‚¹ã‚¿ãƒ åž‹ã€ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã€ ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚ç…§ï¼‰ã‚’æ ¼ç´ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ 次ã®ç‚¹ã¯é‡è¦ãªé•ã„ã«ãªã‚Šã¾ã™ã€‚ コレクションã«æ ¼ç´ã•ã‚ŒãŸã‚ªãƒ–ジェクトãŒã€Œå€¤ã€ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã¨ã—ã¦æ‰±ã‚れるã®ã‹ （ライフサイクルã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚ªãƒ¼ãƒŠãƒ¼ã«å®Œå…¨ã«ä¾å˜ã—ã¾ã™ï¼‰ã€ ã‚‚ã—ãã¯ãれ自身ã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã‚’æŒã£ãŸåˆ¥ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚ç…§ã§ã‚ã‚‹ã‹ã®ã‹ã¨ã„ã†é•ã„ã§ã™ã€‚ 後者ã¯ã€2ã¤ã®ã‚ªãƒ–ジェクト間ã®ã€Œãƒªãƒ³ã‚¯ã€ã‚’コレクションã«ä¿æŒã—ã¦ã„ã‚‹ã¨è¦‹ãªã—ã¦ã„ã‚‹ã ã‘ã§ã™ã€‚"
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr "æ ¼ç´ã•ã‚Œã‚‹åž‹ã¯ <emphasis>コレクションè¦ç´ åž‹</emphasis> ã¨å‘¼ã°ã‚Œã¾ã™ã€‚ コレクションè¦ç´ ã¯ã€<literal><element></literal> ã¾ãŸã¯ <literal><composite-element></literal> ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã•ã‚Œã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚ç…§ã®å ´åˆã«ã¯ <literal><one-to-many></literal> ã¾ãŸã¯ <literal><many-to-many></literal> ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚ 最åˆã®äºŒã¤ã¯å€¤ã¨ã—ã¦è¦ç´ をマッピングã—ã€æ¬¡ã®äºŒã¤ã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®é–¢é€£ã‚’マッピングã™ã‚‹ã®ã«ä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr "インデックス付ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr "setã¨bagを除ãå…¨ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒžãƒƒãƒ”ングã«ã¯ã€ コレクションテーブルã®ä¸ã« <emphasis>インデックス用ã®ã‚«ãƒ©ãƒ </emphasis> ãŒå¿…è¦ã§ã™ã€‚ ãã®ã‚«ãƒ©ãƒ ã«ã€é…列や <literal>List</literal> ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã€ ã‚‚ã—ã㯠<literal>Map</literal> ã®ã‚ーをマッピングã—ã¾ã™ã€‚ <literal>Map</literal> ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã¯ã€ <literal><map-key></literal> ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã•ã‚ŒãŸåŸºæœ¬åž‹ã‹ã€ <literal><map-key-many-to-many></literal> ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã•ã‚ŒãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®é–¢é€£ã‹ã€ ã‚ã‚‹ã„㯠<literal><composite-map-key></literal> ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã•ã‚ŒãŸã‚³ãƒ³ãƒã‚¸ãƒƒãƒˆåž‹ã«ãªã‚Šã¾ã™ã€‚ é…列ã‹ãƒªã‚¹ãƒˆã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã¯ã€å¸¸ã« <literal>integer</literal> åž‹ã§ã€ <literal><list-index></literal> è¦ç´ ã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚ マッピングã•ã‚ŒãŸã‚«ãƒ©ãƒ ã«ã¯ã‚·ãƒ¼ã‚±ãƒ³ã‚·ãƒ£ãƒ«ãªæ•´æ•°ã‚’æ ¼ç´ã—ã¾ã™ï¼!
ˆãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯0ã‹ã‚‰ç•ªå·ãŒä»˜ã‘られã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal>ï¼ˆå¿…é ˆï¼‰:コレクションインデックスã®å€¤ã‚’ä¿æŒã™ã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã€‚ </para> </callout> <callout arearefs=\"index2\"> <para> <literal>base</literal>（オプションã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã¯ <literal>0</literal>）: リストもã—ãã¯é…列ã®æœ€åˆã®è¦ç´ ã«è©²å½“ã™ã‚‹ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚«ãƒ©ãƒ ã®å€¤ã€‚ </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal>（オプション）: コレクションインデックスã®å€¤ã‚’ä¿æŒã™ã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã€‚ </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal>（オプション）: Mapã®ã‚ーを評価ã™ã‚‹ã®ã«ä½¿ã‚れるSQLå¼ã€‚ </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal>ï¼ˆå¿…é ˆï¼‰: Mapã®ã‚ーã®åž‹ã€‚ </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> （オプション）: コレクションインデックスã®å€¤ã®ãŸã‚ã®å¤–部ã‚ーカラムã®åå‰ã€‚ </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> （オプション）: Mapã®ã‚ーã®ãŸã‚ã®å¤–部ã‚ーを評価ã™ã‚‹ãŸã‚ã«ä½¿ã†SQLå¼ã€‚ </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> ï¼ˆå¿…é ˆï¼‰: Mapã®ã‚ーã¨ã—ã¦ä½¿ã‚れるエンティティクラス。 </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr "ã‚‚ã—テーブルã«ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚«ãƒ©ãƒ ãŒãªãã¦ã‚‚ã€ãƒ—ãƒãƒ‘ティ型ã¨ã—㦠<literal>List</literal> を使ã„ãŸã‘ã‚Œã°ã€ Hibernateã® <emphasis><bag></emphasis> ã¨ã—ã¦ãƒ—ãƒãƒ‘ティをマッピングã—ã¾ã™ã€‚ bagã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰å¾©å…ƒã•ã‚Œã‚‹æ™‚ã€é †åºã‚’ä¿æŒã—ã¾ã›ã‚“。 ã—ã‹ã—ã€ï¼ˆãƒ¡ãƒ¢ãƒªä¸Šã§ï¼‰ã‚½ãƒ¼ãƒˆã—ãŸã‚Šã€ï¼ˆSQLã§ï¼‰é †åºä»˜ã‘ã—ãŸã‚Šï¼ˆorder by）ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr "多ãã®ä¸€èˆ¬çš„ãªãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ãƒ¢ãƒ‡ãƒ«ã‚’ã‚«ãƒãƒ¼ã—ãŸãŸã‚ã«ã€ コレクションã®ãŸã‚ã«åˆ©ç”¨ã§ãるマッピングã«ã¯ã‹ãªã‚Šã®å¹…ãŒã‚ã‚Šã¾ã™ã€‚ 様々ãªãƒžãƒƒãƒ”ング宣言ãŒã©ã®ã‚ˆã†ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルã«å¤‰æ›ã•ã‚Œã‚‹ã‹ã‚’知るãŸã‚ã«ã€ スã‚ーマ生æˆãƒ„ールを使ã£ã¦ã¿ã‚‹ã¨è‰¯ã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr "値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¨å¤šå¯¾å¤šé–¢é€£"
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr "値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚„多対多関連ã¯ã€å°‚用㮠<emphasis>コレクションテーブル</emphasis> ãŒå¿…è¦ã§ã™ã€‚ ã“ã®ãƒ†ãƒ¼ãƒ–ルã¯ã€å¤–部ã‚ーカラムã¨ã€ <emphasis>コレクションè¦ç´ ã®ã‚«ãƒ©ãƒ </emphasis> ã¨ã€ å ´åˆã«ã‚ˆã£ã¦ã¯ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚«ãƒ©ãƒ ã‚’æŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr "値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ãŸã‚ã«ã€<literal><element></literal>タグを使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> （オプション）: コレクションã®è¦ç´ ã®å€¤ã‚’ä¿æŒã™ã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã€‚ </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> （オプション）: è¦ç´ を評価ã™ã‚‹ãŸã‚ã«ä½¿ã†SQLå¼ã€‚ </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> ï¼ˆå¿…é ˆï¼‰ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ã®åž‹ã€‚ </para> </callout> </calloutlist> </programlistingco> <para> <emphasis>多対多関連</emphasis> 㯠<literal><many-to-many></literal> è¦ç´ ã§æŒ‡å®šã—ã¾ã™ã€‚ </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=!
\"8 60\"/> <area id=\"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> （オプション）: 外部ã‚ーカラムã®è¦ç´ ã®åå‰ã€‚ </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> （オプション）: 外部ã‚ー値ã®è¦ç´ を評価ã™ã‚‹ãŸã‚ã«ä½¿ã†SQLå¼ã€‚ </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> ï¼ˆå¿…é ˆï¼‰: 関連クラスã®åå‰ã€‚ </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (オプション - デフォルト㯠<literal>join</literal>): 関連ã®ãŸã‚ã«ã€å¤–部çµåˆã‹é †æ¬¡é¸æŠžãƒ•ã‚§ãƒƒãƒã‚’有効ã«ã—ã¾ã™ã€‚ ã“ã‚Œã¯ç‰¹æ®Šãªã‚±ãƒ¼ã‚¹ã§ã™ãŒã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨ã®å¤šå¯¾å¤šé–¢ä¿‚ã‚’ （１ã¤ã® <literal>SELECT</literal> ã«ã‚ˆã‚Šï¼‰å®Œå…¨ã«å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ãŸã‚ã«ã¯ã€ ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³è‡ªä½“ã ã‘ã§ãªã〠ãƒã‚¹ã!
ƒˆã—ãŸè¦ç´ ã§ã‚ã‚‹ <literal><many-to-many></literal> ã®ã“ã®å±žæ€§ã«ã¤ã„ã¦ã‚‚ <literal>join</literal> フェッãƒã‚’有効ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> （オプション）: 外部ã‚ーカラムã®ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ã®DDL生æˆã‚’有効ã«ã—ã¾ã™ã€‚ ã“ã‚Œã¯ã€é–¢é€£ã®å¤šé‡åº¦ã‚’事実上一対多ã«ã—ã¾ã™ã€‚ </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> （オプション - デフォルト㯠<literal>exception</literal>） å‚照先ã®è¡ŒãŒãªã„外部ã‚ーをã©ã®ã‚ˆã†ã«æ‰±ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ <literal>ignore</literal> ã«ã™ã‚‹ã¨ã€è¡ŒãŒãªã„ã“ã¨ã‚’関連ãŒç„¡ã„ã‚‚ã®ã¨ã—ã¦æ‰±ã„ã¾ã™ã€‚ </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> （オプション）: <literal>class</literal> ã®ä»£æ›¿ã§ã‚る関連クラスã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å。 <lite!
ral>class</literal> ã®ä»£ã‚ã‚Šã«æŒ‡å®šã™ã‚‹ã€é–¢é€£ã‚¯ãƒ©ã‚¹ã®ã‚
¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å。 </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: （オプション） ã“ã®å¤–部ã‚ーã«çµåˆã™ã‚‹é–¢é€£ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティå。 指定ã—ãªã‹ã£ãŸå ´åˆã¯ã€é–¢é€£ã‚¯ãƒ©ã‚¹ã®ä¸»ã‚ーを使ã„ã¾ã™ã€‚ </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr "以下ã«ã„ãã¤ã‹ä¾‹ã‚’示ã—ã¾ã™ã€‚ ã¾ãšã¯Stringã®setã«é–¢ã—ã¦ã®ä¾‹ã§ã™ã€‚"
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr "整数値をå«ã‚€bag（bag㯠<literal>order-by</literal> 属性ã«ã‚ˆã£ã¦åå¾©é †åºãŒå®šç¾©ã•ã‚Œã¦ã„ã¾ã™ï¼‰"
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr "エンティティã®é…列 - ã“ã®å ´åˆã€å¤šå¯¾å¤šã®é–¢é€£ã§ã™ã€‚"
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr "æ–‡å—列ã¨æ—¥ä»˜ã®map"
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr "コンãƒãƒ¼ãƒãƒ³ãƒˆã®list（次ã®ç« ã§è©³ã—ã説明ã—ã¾ã™ï¼‰"
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr "一対多関連"
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr "<emphasis>一対多関連</emphasis> ã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï½¥ãƒ†ãƒ¼ãƒ–ルを介ã•ãšã€ 外部ã‚ーã«ã‚ˆã‚Š2ã¤ã®ã‚¯ãƒ©ã‚¹ã®ãƒ†ãƒ¼ãƒ–ルを関連付ã‘ã¾ã™ã€‚ ã“ã®ãƒžãƒƒãƒ”ングã¯æ¨™æº–çš„ãªJavaã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’ã„ãã¤ã‹å¤±ã„ã¾ã™ã€‚"
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr "エンティティクラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ 2ã¤ä»¥ä¸Šã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«å±žã—ã¦ã¯ã„ã‘ã¾ã›ã‚“。"
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr "コレクションã«å«ã¾ã‚Œã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ コレクションインデックスã®å€¤ã¨ã—ã¦2度以上ç¾ã‚Œã¦ã¯ã„ã‘ã¾ã›ã‚“。"
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr "<literal>Product</literal> ã‹ã‚‰ <literal>Part</literal> ã¸ã®é–¢é€£ã¯ã€ <literal>Part</literal> テーブルã¸ã®å¤–部ã‚ーカラムã¨ã€å ´åˆã«ã‚ˆã£ã¦ã¯ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚«ãƒ©ãƒ ãŒå¿…è¦ã§ã™ã€‚ <literal><one-to-many></literal> ã‚¿ã‚°ã¯ã€ã“ã‚ŒãŒä¸€å¯¾å¤šé–¢é€£ã§ã‚ã‚‹ã“ã¨ã‚’表ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr "<literal>class</literal> ï¼ˆå¿…é ˆï¼‰: 関連クラスã®åå‰ã€‚"
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>not-found</literal> （オプション - デフォルト㯠<literal>exception</literal>）: å‚照先ã®è¡ŒãŒãªã„ã‚ャッシュã•ã‚ŒãŸè˜åˆ¥åã‚’ã©ã®ã‚ˆã†ã«æ‰±ã†ã‹ã‚’指定ã—ã¾ã™ã€‚ <literal>ignore</literal> を指定ã™ã‚‹ã¨ã€è¡ŒãŒãªã„ã“ã¨ã‚’関連ãŒãªã„ã‚‚ã®ã¨ã—ã¦æ‰±ã„ã¾ã™ã€‚"
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr "<literal>entity-name</literal> （オプション）: <literal>class</literal> ã®ä»£æ›¿ã§ã‚る関連クラスã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å。 <literal>class</literal> ã®ä»£ã‚ã‚Šã«æŒ‡å®šã™ã‚‹ã€é–¢é€£ã‚¯ãƒ©ã‚¹ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£å。"
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr "<literal><one-to-many></literal> è¦ç´ ã¯ã‚«ãƒ©ãƒ を宣言ã™ã‚‹å¿…è¦ãŒãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 åŒæ§˜ã« <literal>テーブル</literal> åを指定ã™ã‚‹å¿…è¦ã‚‚ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr "<emphasis>ã¨ã¦ã‚‚é‡è¦ãªæ³¨æ„:</emphasis> ã‚‚ã— <literal><one-to-many></literal> 関連ã®å¤–部ã‚ーカラム㌠<literal>NOT NULL</literal>ã¨å®£è¨€ã•ã‚ŒãŸå ´åˆã€ <literal><key></literal> マッピング㫠<literal>not-null=\"true\"</literal> を宣言ã™ã‚‹ã‹ã€ コレクションマッピング㫠<literal>inverse=\"true\"</literal> を付ã‘ãŸä¸Šã§ã€ <emphasis>åŒæ–¹å‘関連を使ã†</emphasis> å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ åŒæ–¹å‘関連ã«ã¤ã„ã¦ã¯ã“ã®ç« ã®å¾Œã®ã»ã†ã§èª¬æ˜Žã—ã¾ã™ã€‚"
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr "次ã®ä¾‹ã¯ã€å称（<literal>Part</literal> ã®æ°¸ç¶šçš„ãªãƒ—ãƒãƒ‘ティã§ã‚ã‚‹ <literal>partName</literal>） ã«ã‚ˆã‚‹ <literal>Part</literal> エンティティã®mapを表ã—ã¦ã„ã¾ã™ã€‚ formulaã«ã‚ˆã‚‹ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’使ã£ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr "高度ãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï½¥ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr "ソートã•ã‚ŒãŸã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr "Hibernate㯠<literal>java.util.SortedMap</literal> 㨠<literal>java.util.SortedSet</literal> を実装ã—ãŸã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ 開発者ã¯ãƒžãƒƒãƒ”ング定義ファイルã«ã‚³ãƒ³ãƒ‘レータを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr "<literal>sort</literal> 属性ã«è¨å®šã§ãる値㯠<literal>unsorted</literal> 㨠<literal>natural</literal> ãŠã‚ˆã³ã€<literal>java.util.Comparator</literal> を実装ã—ãŸã‚¯ãƒ©ã‚¹ã®åå‰ã§ã™ã€‚"
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr "ソートã•ã‚ŒãŸã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯å®Ÿè³ªçš„ã«ã¯ <literal>java.util.TreeSet</literal> ã‚„ <literal>java.util.TreeMap</literal> ã®ã‚ˆã†ã«æŒ¯èˆžã„ã¾ã™ã€‚"
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr "ã‚‚ã—データベース自身ã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ を並ã¹ã•ã›ãŸã„ãªã‚‰ã€ <literal>set</literal> ã‚„ <literal>bag</literal>ã€<literal>map</literal> ã® <literal>order-by</literal> 属性を使ã„ã¾ã™ã€‚ ã“ã®è§£æ±ºæ³•ã¯JDK1.4ã€ã‚‚ã—ãã¯ãれ以上ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã§åˆ©ç”¨å¯èƒ½ã§ã™ （<literal>LinkedHashSet</literal> ã¾ãŸã¯ <literal>LinkedHashMap</literal>を使ã£ã¦å®Ÿè£…ã•ã‚Œã¦ã„ã¾ã™ï¼‰ã€‚ 整列ã¯ãƒ¡ãƒ¢ãƒªä¸Šã§ã¯ãªãã€SQLクエリ内ã§å®Ÿè¡Œã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr "<literal>order-by</literal> 属性ã®å€¤ãŒSQL命令ã§ã‚ã£ã¦ã€HQL命令ã§ã¯ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„ï¼"
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr "関連ã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã® <literal>filter()</literal> を使ã†ã“ã¨ã§ã€ 実行時ã«ä»»æ„ã®criteriaã«ã‚ˆã£ã¦ã‚½ãƒ¼ãƒˆã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr "åŒæ–¹å‘関連"
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr "<emphasis>åŒæ–¹å‘関連</emphasis> ã¯é–¢é€£ã®ã©ã¡ã‚‰ã€Œå´ã€ã‹ã‚‰ã§ã‚‚ナビゲーションã§ãã¾ã™ã€‚ 2種類ã®åŒæ–¹å‘関連ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr "one-to-many"
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr "片å´ãŒsetã‹bagã€ã‚‚ã†ç‰‡æ–¹ãŒå˜ä¸€å€¤ã§ã™ã€‚"
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr "many-to-many"
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr "両å´ãŒsetã‹bagã§ã™ã€‚"
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr "2ã¤ã®å¤šå¯¾å¤šé–¢é€£ã§åŒã˜ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルをマッピングã—〠片方を <emphasis>inverse</emphasis> ã¨ã—ã¦å®£è¨€ã™ã‚‹ã“ã¨ã§ã€ åŒæ–¹å‘ã®å¤šå¯¾å¤šé–¢é€£ã‚’指定ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ （ã©ã¡ã‚‰ã‚’inverseã«é¸ã‚“ã ã¨ã—ã¦ã‚‚ã€ãã¡ã‚‰å´ã«ã¯ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ä½¿ãˆã¾ã›ã‚“）。"
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr "次ã«åŒæ–¹å‘ã®å¤šå¯¾å¤šé–¢é€£ã®ä¾‹ã‚’示ã—ã¾ã™ã€‚ å„カテゴリã¯å¤šæ•°ã®ã‚¢ã‚¤ãƒ†ãƒ ã‚’æŒã¤ã“ã¨ãŒã§ãã€å„アイテムã¯å¤šãã®ã‚«ãƒ†ã‚´ãƒªã«å±žã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>
+\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr "関連ã®inverseå´ã«ã®ã¿è¡Œã‚ã‚ŒãŸå¤‰æ›´ã¯æ°¸ç¶šåŒ– <emphasis>ã•ã‚Œã¾ã›ã‚“</emphasis>。 ã“ã‚Œã¯ã€Hibernateã¯å…¨ã¦ã®åŒæ–¹å‘関連ã«ã¤ã„ã¦ã€ãƒ¡ãƒ¢ãƒªä¸Šã«ï¼’ã¤ã®è¡¨ç¾ã‚’æŒã£ã¦ã„ã‚‹ã¨ã„ã†æ„味ã§ã™ã€‚ ã¤ã¾ã‚Šä¸€ã¤ã¯Aã‹ã‚‰Bã¸ã®ãƒªãƒ³ã‚¯ã§ã€ã‚‚ã†ä¸€ã¤ã¯Bã‹ã‚‰Aã¸ã®ãƒªãƒ³ã‚¯ã¨ã„ã†ã“ã¨ã§ã™ã€‚ Javaã®ã‚ªãƒ–ジェクトモデルã«ã¤ã„ã¦è€ƒãˆã€Javaã§åŒæ–¹å‘関係をã©ã†ã‚„ã£ã¦ä½œã‚‹ã‹ã‚’考ãˆã‚Œã°ã€ ã“ã‚Œã¯ç†è§£ã—ã‚„ã™ã„ã§ã™ã€‚下記ã«ã€Javaã§ã®åŒæ–¹å‘関連を示ã—ã¾ã™ã€‚"
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr "関連ã®inverseã§ã¯ãªã„å´ã¯ã€ãƒ¡ãƒ¢ãƒªä¸Šã®è¡¨ç¾ã‚’データベースã«ä¿å˜ã™ã‚‹ã®ã«ä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr "åŒæ–¹å‘ã®ä¸€å¯¾å¤šé–¢é€£ã‚’定義ã™ã‚‹ã«ã¯ã€ 一対多関連を多対一関連ã¨åŒã˜ãƒ†ãƒ¼ãƒ–ルã®ã‚«ãƒ©ãƒ ã«ãƒžãƒƒãƒ”ングã—〠多å´ã« <literal>inverse=\"true\"</literal> ã¨å®£è¨€ã—ã¾ã™ã€‚"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr "関連ã®ç‰‡å´ã« <literal>inverse=\"true\"</literal> ã‚’è¨å®šã—ã¦ã‚‚〠カスケードæ“作ã«å½±éŸ¿ã‚’与ãˆã¾ã›ã‚“。ã“れらã¯ç›´äº¤ã—ãŸæ¦‚念ã§ã™ï¼"
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr "インデックス付ãコレクションã¨åŒæ–¹å‘関連"
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr "片å´ãŒ <literal><list></literal> ã‚„ <literal><map></literal> ã§ã‚ã‚‹ åŒæ–¹å‘関連ã¯ã€ç‰¹ã«ã‚ˆã考ãˆã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ インデックスカラムã«ãƒžãƒƒãƒ—ã•ã‚Œã‚‹åクラスã®ãƒ—ãƒãƒ‘ティãŒã‚ã‚‹å ´åˆã¯ã€å•é¡Œãªã„ã§ã™ã€‚ コレクションã®ãƒžãƒƒãƒ”ング㧠<literal>inverse=\"true\"</literal> を使ã„続ã‘られã¾ã™ã€‚"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr "ã—ã‹ã—ã€åクラスã«ãã®ã‚ˆã†ãªãƒ—ãƒãƒ‘ティãŒãªã„å ´åˆã¯ã€ 関連を真ã«åŒæ–¹å‘ã§ã‚ã‚‹ã¨è€ƒãˆã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“ （関連ã®ç‰‡å´ã«åˆ©ç”¨ã§ãã‚‹æƒ…å ±ãŒã‚ã‚Šã¾ã™ãŒã€ã‚‚ã†ä¸€æ–¹ã«ã¯ã‚ã‚Šã¾ã›ã‚“）。 ã“ã®å ´åˆã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã« <literal>inverse=\"true\"</literal> をマッピングã§ãã¾ã›ã‚“。 代ã‚ã‚Šã«ã€æ¬¡ã®ã‚ˆã†ãªãƒžãƒƒãƒ”ングãŒä½¿ãˆã¾ã™ã€‚"
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr "注æ„： ã“ã®ãƒžãƒƒãƒ”ングã§ã¯ã€é–¢é€£ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³å€¤ã®å´ã¯ã€ 外部ã‚ーをアップデートã™ã‚‹è²¬ä»»ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr "3é …é–¢é€£"
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr "3é …é–¢é€£ã®ãƒžãƒƒãƒ”ングã«ã¯3ã¤ã®ã‚¢ãƒ—ãƒãƒ¼ãƒãŒã‚ã‚Šã¾ã™ã€‚ 1ã¤ç›®ã¯é–¢é€£ã‚’インデックスã¨ã—㦠<literal>Map</literal> を使用ã™ã‚‹ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã™ã€‚"
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr "2ã¤ç›®ã¯å˜ç´”ã«é–¢é€£ã‚’エンティティ･クラスã¨ã—ã¦ãƒ¢ãƒ‡ãƒ«ã‚’作り直ã™ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã€ é »ç¹ã«ä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr "最後ã¯compositeè¦ç´ を使ã†ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã™ã€‚ã“ã‚Œã«é–¢ã™ã‚‹è°è«–ã¯å¾Œã»ã©è¡Œã„ã¾ã™ã€‚"
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr "<literal><idbag></literal>ã®ä½¿ç”¨"
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr "複åˆã‚ーã¯æ‚ªã„ã‚‚ã®ã§ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¯äººå·¥ã®è˜åˆ¥å(代ç†ã‚ー)ã‚’æŒã¤ã¹ãã§ã‚ã‚‹ã¨ã„ã†è€ƒãˆæ–¹ã‹ã‚‰ã¯ã€ 多対多関連ã¨å€¤ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’複åˆã‚ーを用ã„ãŸãƒ†ãƒ¼ãƒ–ルã¸ãƒžãƒƒãƒ”ングã™ã‚‹ã®ã¯å°‘ã—奇妙ã«æ„Ÿã˜ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“ï¼ ç¢ºã‹ã«ã“ã®è€ƒãˆæ–¹ã«ã¯è°è«–ã®ä½™åœ°ãŒã‚ã‚Šã¾ã™ã€‚ 純粋ãªé–¢é€£ãƒ†ãƒ¼ãƒ–ルã¯ä»£ç†ã‚ーを使ã£ã¦ã‚‚利益を得られãªã„よã†ã«æ€ãˆã‚‹ã‹ã‚‰ã§ã™ （åˆæˆå€¤ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯åˆ©ç›ŠãŒã‚ã‚‹ <emphasis>ã‹ã‚‚</emphasis> ã—ã‚Œã¾ã›ã‚“ãŒï¼‰ã€‚ ã¨ã¯ã„ãˆã€Hibernateã¯ä»£ç†ã‚ーをæŒã¤ãƒ†ãƒ¼ãƒ–ルã¸å¤šå¯¾å¤šé–¢é€£ã¨å€¤ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ マッピングã™ã‚‹æ©Ÿèƒ½ã‚‚å‚™ãˆã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr "bagã®ã‚»ãƒžãƒ³ãƒ†ã‚£ãƒƒã‚¯ã‚¹ã‚’æŒã£ãŸ <literal>List</literal>（ã¾ãŸã¯ <literal>Collection</literal>）を <literal><idbag></literal> è¦ç´ ã«ãƒžãƒƒãƒ”ングã§ãã¾ã™ã€‚"
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr "ã”å˜çŸ¥ã®ã‚ˆã†ã« <literal><idbag></literal> ã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ï½¥ã‚¯ãƒ©ã‚¹ã®ã‚ˆã†ã« 人工的ãªidジェãƒãƒ¬ãƒ¼ã‚¿ã‚’æŒã£ã¦ã„ã¾ã™ï¼ ç•°ãªã‚‹ä»£ç†ã‚ーをãã‚Œãžã‚Œã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®åˆ—ã«å‰²ã‚Šå½“ã¦ã¾ã™ã€‚ ã—ã‹ã—ãªãŒã‚‰ã€Hibernateã¯ã‚ã‚‹è¡Œã®ä»£ç†ã‚ーã®å€¤ã‚’見ã¤ã‘出ã™æ©Ÿæ§‹ã‚’æŒã£ã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr "<literal><idbag></literal> ã‚’æ›´æ–°ã™ã‚‹ãƒ‘フォーマンス㯠通常㮠<literal><bag></literal> よりも良ã„ã“ã¨ã«æ³¨ç›®ã—ã¦ãã ã•ã„ï¼ Hibernateã¯å€‹ã€…ã®è¡Œã‚’効果的ã«è¦‹ã¤ã‘ã‚‹ã“ã¨ãŒã§ã〠listã‚„mapã€setã®ã‚ˆã†ã«å€‹åˆ¥ã«ãã®è¡Œã‚’æ›´æ–°ã€å‰Šé™¤ã§ãã¾ã™ã€‚"
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr "ç¾åœ¨ã®å®Ÿè£…ã§ã¯ã€<literal>native</literal> ã¨ã„ã†id生æˆæˆ¦ç•¥ã‚’ <literal><idbag></literal> コレクションã®è˜åˆ¥åã«å¯¾ã—ã¦ä½¿ãˆã¾ã›ã‚“。"
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr "コレクションã®ä¾‹"
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr "ã“ã‚Œã¾ã§ã®ç¯€ã®èª¬æ˜Žã§ã¯ç†è§£ã—ã«ãã„ã®ã§ã€ä»¥ä¸‹ã®ä¾‹ã‚’見ã¦ãã ã•ã„。"
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr "ã“ã®ã‚¯ãƒ©ã‚¹ã¯ <literal>Child</literal> インスタンスã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’æŒã£ã¦ã„ã¾ã™ã€‚ ã‚‚ã—å„々ã®childãŒæœ€å¤§ã§ã‚‚一ã¤ã®parentã‚’æŒã£ã¦ã„ã‚‹ãªã‚‰ã°ã€æœ€ã‚‚自然ãªãƒžãƒƒãƒ”ングã¯ä¸€å¯¾å¤šé–¢é€£ã§ã™ã€‚"
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr "ã“ã‚Œã¯ä»¥ä¸‹ã®ãƒ†ãƒ¼ãƒ–ル定義ã«ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚"
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr "ã‚‚ã—parent㌠<emphasis>è¦æ±‚</emphasis> ã•ã‚Œã‚‹ãªã‚‰ã€åŒæ–¹å‘ã®ä¸€å¯¾å¤šé–¢é€£ã‚’使用ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr "<literal>NOT NULL</literal> 制約ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr "ã‚ã‚‹ã„ã¯ã€ã‚‚ã—ã“ã®é–¢é€£ã¯å˜æ–¹å‘ã§ã‚ã‚‹ã¹ãã¨å¼·ã主張ã™ã‚‹ã®ã§ã‚ã‚Œã°ã€ <literal><key></literal> ã« <literal>NOT NULL</literal> 制約を宣言ã§ãã¾ã™ã€‚"
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr "一方ã§ã€ã‚‚ã—childãŒè¤‡æ•°ã®parentã‚’æŒã¦ã‚‹ãªã‚‰ã°ã€å¤šå¯¾å¤šé–¢é€£ãŒå¦¥å½“ã§ã™ã€‚"
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr "テーブル定義ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr "parent/child関係ã®ãƒžãƒƒãƒ”ングã«ã¤ã„ã¦ã®ã‚ˆã‚Šå¤šãã®ä¾‹ã‚„完全ãªæ‰‹é †ãŒå¿…è¦ã§ã‚ã‚Œã°ã€ <xref linkend=\"example-parentchild\"/> ã‚’ã”覧ãã ã•ã„。"
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr "ã¾ãŸã€ã•ã‚‰ã«ç‰¹æ®Šãªé–¢é€£ãƒžãƒƒãƒ”ングもå¯èƒ½ã§ã™ã€‚次ã®ç« ã§è©³ã—ãè¿°ã¹ã¾ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,679 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr "コンãƒãƒ¼ãƒãƒ³ãƒˆã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr "<emphasis>コンãƒãƒ¼ãƒãƒ³ãƒˆ</emphasis> ã®æ¦‚念ã¯ã€Hibernateを通ã—ã¦æ§˜ã€…ãªçŠ¶æ³ã®ä¸ã§ ç•°ãªã‚‹ç›®çš„ã®ãŸã‚ã«å†åˆ©ç”¨ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr "ä¾å˜ã‚ªãƒ–ジェクト"
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr "コンãƒãƒ¼ãƒãƒ³ãƒˆã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å‚ç…§ã§ã¯ãªã値型ã¨ã—ã¦æ°¸ç¶šåŒ–ã•ã‚ŒãŸã€ 包å«ã•ã‚ŒãŸã‚ªãƒ–ジェクトã§ã™ã€‚コンãƒãƒ¼ãƒãƒ³ãƒˆã¨ã„ã†è¨€è‘‰ã«ã¤ã„ã¦ã¯ã€ã‚³ãƒ³ãƒã‚¸ã‚·ãƒ§ãƒ³ã¨ã„ㆠオブジェクト指å‘ã®æ¦‚念をå‚ç…§ã—ã¦ãã ã•ã„（アーã‚テクãƒãƒ£ãƒ¬ãƒ™ãƒ«ã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã§ã¯ã‚ã‚Šã¾ã›ã‚“）。 例ãˆã°ã€ä»¥ä¸‹ã®Personモデルã®ã‚ˆã†ãªã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Person {
+\n"
+ " private java.util.Date birthday;
+\n"
+ " private Name name;
+\n"
+ " private String key;
+\n"
+ " public String getKey() {
+\n"
+ " return key;
+\n"
+ " }
+\n"
+ " private void setKey(String key) {
+\n"
+ " this.key=key;
+\n"
+ " }
+\n"
+ " public java.util.Date getBirthday() {
+\n"
+ " return birthday;
+\n"
+ " }
+\n"
+ " public void setBirthday(java.util.Date birthday) {
+\n"
+ " this.birthday = birthday;
+\n"
+ " }
+\n"
+ " public Name getName() {
+\n"
+ " return name;
+\n"
+ " }
+\n"
+ " public void setName(Name name) {
+\n"
+ " this.name = name;
+\n"
+ " }
+\n"
+ " ......
+\n"
+ " ......
+\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Name {
+\n"
+ " char initial;
+\n"
+ " String first;
+\n"
+ " String last;
+\n"
+ " public String getFirst() {
+\n"
+ " return first;
+\n"
+ " }
+\n"
+ " void setFirst(String first) {
+\n"
+ " this.first = first;
+\n"
+ " }
+\n"
+ " public String getLast() {
+\n"
+ " return last;
+\n"
+ " }
+\n"
+ " void setLast(String last) {
+\n"
+ " this.last = last;
+\n"
+ " }
+\n"
+ " public char getInitial() {
+\n"
+ " return initial;
+\n"
+ " }
+\n"
+ " void setInitial(char initial) {
+\n"
+ " this.initial = initial;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr "ã„ã¾ã€<literal>Name</literal> 㯠<literal>Person</literal> ã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¨ã—㦠永続化ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ã“ã“㧠<literal>Name</literal> ã¯æ°¸ç¶šåŒ–属性ã«å¯¾ã—ã¦getter〠setterメソッドを定義ã—ã¾ã™ãŒã€ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚„è˜åˆ¥åプãƒãƒ‘ティを定義ã™ã‚‹å¿…è¦ãŒ ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ä¸‹ã•ã„。"
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr "マッピング定義ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">
+\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">
+\n"
+ " <generator class=\"uuid\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"birthday\" type=\"date\"/>
+\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->
+\n"
+ " <property name=\"initial\"/>
+\n"
+ " <property name=\"first\"/>
+\n"
+ " <property name=\"last\"/>
+\n"
+ " </component>
+\n"
+ "</class>]]>"
+
+#: index.docbook:38
+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> カラムをæŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr "å…¨ã¦ã®å€¤åž‹ã®ã‚ˆã†ã«ã€ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¯å‚ç…§ã®å…±æœ‰ã‚’ã™ã‚‹ã“ã¨ãŒã§ãã¾ã›ã‚“。 言ã„æ›ãˆã‚‹ã¨ã€äºŒäººã®Personã¯åŒã˜åå‰ã‚’æŒã¤ã“ã¨ãŒã§ãã¾ã™ãŒã€äºŒã¤ã®Personオブジェクト㯠\"値ãŒåŒã˜ã ã‘\"ã®åˆ¥ã€…ã®nameオブジェクトをå«ã‚“ã§ã„ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ コンãƒãƒ¼ãƒãƒ³ãƒˆã®null値ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã¯ <emphasis>アドホック</emphasis> ã§ã™ã€‚ コンãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚ªãƒ–ジェクトをå†èªã¿è¾¼ã¿ã™ã‚‹éš›ã€Hibernateã¯ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã®ã™ã¹ã¦ã®ã‚«ãƒ©ãƒ ㌠nullã§ã‚ã‚‹ãªã‚‰ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆè‡ªä½“ãŒnullã§ã‚ã‚‹ã¨è€ƒãˆã¾ã™ã€‚ ã“ã‚Œã¯å¤§æŠµã®å ´åˆå•é¡Œã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr "コンãƒãƒ¼ãƒãƒ³ãƒˆã®å±žæ€§ã¯ã©ã‚“ãªHibernateã®åž‹ã§ã‚‚構ã„ã¾ã›ã‚“（コレクションã€many-to-one関連〠他ã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆãªã©ï¼‰ã€‚ãƒã‚¹ãƒˆã•ã‚ŒãŸã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã¯æ»…多ã«ä½¿ã‚ãªã„ã¨è€ƒãˆã‚‹ã¹ãã§ã¯ <emphasis>ã‚ã‚Šã¾ã›ã‚“</emphasis> 。Hibernateã¯éžå¸¸ã«ãã‚ã®ç´°ã‹ã„オブジェクトモデルをサãƒãƒ¼ãƒˆã™ã‚‹ã‚ˆã†ã«æ„図ã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal><component></literal> è¦ç´ ã¯è¦ªã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®é€†å‚ç…§ã¨ã—ã¦ã€ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚¯ãƒ©ã‚¹ã® 属性をマッピングã™ã‚‹ <literal><parent></literal> サブè¦ç´ を使用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">
+\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">
+\n"
+ " <generator class=\"uuid\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"birthday\" type=\"date\"/>
+\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">
+\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->
+\n"
+ " <property name=\"initial\"/>
+\n"
+ " <property name=\"first\"/>
+\n"
+ " <property name=\"last\"/>
+\n"
+ " </component>
+\n"
+ "</class>]]>"
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr "従属ã™ã‚‹ã‚ªãƒ–ジェクトã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr "Hibernateã¯ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ï¼ˆä¾‹ãˆã° <literal>Name</literal> åž‹ã®é…列）。 <literal><element></literal> ã‚¿ã‚°ã‚’ <literal><composite-element></literal> ã‚¿ã‚°ã«å–り替ãˆã‚‹ã“ã¨ã«ã‚ˆã‚Š コンãƒãƒ¼ãƒãƒ³ãƒˆã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’宣言ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">
+\n"
+ " <key column=\"id\"/>
+\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->
+\n"
+ " <property name=\"initial\"/>
+\n"
+ " <property name=\"first\"/>
+\n"
+ " <property name=\"last\"/>
+\n"
+ " </composite-element>
+\n"
+ "</set>]]>"
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr "注æ„: コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã® <literal>Set</literal> を定義ã—ãŸãªã‚‰ã€ <literal>equals()</literal> 㨠<literal>hashCode()</literal> ã‚’æ£ã—ã実装ã™ã‚‹ã“ã¨ãŒé‡è¦ã§ã™ã€‚"
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr "コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’å«ã¾ãšã€ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚’å«ã‚€ã“ã¨ã‚‚ã‚ã‚Šã¾ã™ã€‚ コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆè‡ªèº«ãŒã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚’å«ã‚“ã§ã„ã‚‹å ´åˆã¯ <literal><nested-composite-element></literal> ã‚’ 使用ã—ã¦ãã ã•ã„。コンãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³è‡ªèº«ãŒã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚’æŒã¤ã¨ã„ã†ã‚±ãƒ¼ã‚¹ã¯ã‚ã£ãŸã«ã‚ã‚Šã¾ã›ã‚“。 ã“ã®æ®µéšŽã¾ã§ã«ã€one-to-many関連ã®æ–¹ãŒã‚ˆã‚Šé©åˆ‡ã§ãªã„ã‹ã¨ç†Ÿè€ƒã—ã¦ãã ã•ã„。 コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã‚’エンティティã¨ã—ã¦å†åº¦ãƒ¢ãƒ‡ãƒªãƒ³ã‚°ã—ã¦ã¿ã¦ãã ã•ã„。 ã—ã‹ã—ã“ã‚Œã¯Javaã®ãƒ¢ãƒ‡ãƒ«ã¨ã—ã¦ã¯åŒã˜ã§ã™ãŒã€ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ãƒ¢ãƒ‡ãƒ«ã¨æ°¸ç¶šå‹•ä½œã¯ã¾ã 若干異ãªã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr "ã‚‚ã— <literal><set></literal> を使用ã™ã‚‹ã®ã§ã‚ã‚Œã°ã€ã‚³ãƒ³ãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã®ãƒžãƒƒãƒ”ングãŒnull値ãŒå¯èƒ½ãª 属性をサãƒãƒ¼ãƒˆã—ã¦ã„ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。Hibernateã¯ã‚ªãƒ–ジェクトを削除ã™ã‚‹ã¨ã〠レコードをè˜åˆ¥ã™ã‚‹ãŸã‚ã«ãã‚Œãžã‚Œã®ã‚«ãƒ©ãƒ ã®å€¤ã‚’使用ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãŸã‚ã€null値をæŒã¤ã“ã¨ãŒå‡ºæ¥ã¾ã›ã‚“ （コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆãƒ†ãƒ¼ãƒ–ルã«ã¯åˆ¥ã®ä¸»ã‚ーカラムã¯ã‚ã‚Šã¾ã›ã‚“）。 コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã«not-nullã®å±žæ€§ã®ã¿ã‚’使用ã™ã‚‹ã‹ã€ã¾ãŸã¯ <literal><list></literal>ã€<literal><map></literal>〠<literal><bag></literal>ã€<literal><idbag></literal> ã‚’é¸æŠžã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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><many-to-one></literal> 属性をæŒã¤ コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆãŒã‚ã‚Šã¾ã™ã€‚ ã“ã®ãƒžãƒƒãƒ”ングã¯ã€ã‚³ãƒ³ãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã‚¯ãƒ©ã‚¹ã‚’多対多関連テーブル㮠余分ãªã‚«ãƒ©ãƒ ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚ 次ã®ä¾‹ã¯ <literal>Order</literal> ã‹ã‚‰ã€<literal>Item</literal> ã¸ã®å¤šå¯¾å¤šé–¢é€£ã§ã™ã€‚ <literal>purchaseDate</literal>ã€<literal>price</literal>ã€<literal>quantity</literal> ã¯é–¢é€£ã®å±žæ€§ã¨ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >
+\n"
+ " ....
+\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">
+\n"
+ " <key column=\"order_id\">
+\n"
+ " <composite-element class=\"eg.Purchase\">
+\n"
+ " <property name=\"purchaseDate\"/>
+\n"
+ " <property name=\"price\"/>
+\n"
+ " <property name=\"quantity\"/>
+\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->
+\n"
+ " </composite-element>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr "ã‚‚ã¡ã‚ã‚“ã€åŒæ–¹å‘関連ã®ãƒŠãƒ“ゲーションã®ãŸã‚ã«å対å´ã‹ã‚‰purchaseã¸ã®å‚照を作るã“ã¨ã¯å‡ºæ¥ã¾ã›ã‚“。 コンãƒãƒ¼ãƒãƒ³ãƒˆã¯å€¤åž‹ã§ã‚ã‚Šã€å‚照を共有ã§ããªã„ã“ã¨ã‚’覚ãˆã¦ãŠã„ã¦ãã ã•ã„。 一ã¤ã® <literal>Purchase</literal> ã¯ä¸€ã¤ã® <literal>Order</literal> ã®setã«å˜åœ¨ã§ãã¾ã™ãŒã€ åŒæ™‚ã« <literal>Item</literal> ã‹ã‚‰å‚ç…§ã™ã‚‹ã“ã¨ã¯å‡ºæ¥ã¾ã›ã‚“。"
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr "3é …é–¢é€£ï¼ˆã‚ã‚‹ã„ã¯4é …ãªã©ï¼‰ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >
+\n"
+ " ....
+\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">
+\n"
+ " <key column=\"order_id\">
+\n"
+ " <composite-element class=\"eg.OrderLine\">
+\n"
+ " <many-to-one name=\"purchaseDetails\" class=\"eg.Purchase\"/>
+\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>
+\n"
+ " </composite-element>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr "コンãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã¯ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®é–¢é€£ã¨ã—ã¦ã€ åŒã˜ã‚·ãƒ³ã‚¿ãƒƒã‚¯ã‚¹ã‚’使ã£ã¦ã„るクエリ内ã§ä½¿ç”¨ã§ãã¾ã™ã€‚"
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr "Mapã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã¨ã—ã¦ã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆ"
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr "<literal><composite-map-key></literal> è¦ç´ 㯠<literal>Map</literal> ã®ã‚ーã¨ã—ã¦ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚¯ãƒ©ã‚¹ã‚’ マッピングã—ã¾ã™ã€‚コンãƒãƒ¼ãƒãƒ³ãƒˆã‚¯ãƒ©ã‚¹ä¸Šã§ <literal>hashCode()</literal> 㨠<literal>equals()</literal> ã‚’æ£ç¢ºã«ã‚ªãƒ¼ãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr "複åˆè˜åˆ¥åã¨ã—ã¦ã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆ"
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr "コンãƒãƒ¼ãƒãƒ³ãƒˆã‚’エンティティクラスã®è˜åˆ¥åã¨ã—ã¦ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ コンãƒãƒ¼ãƒãƒ³ãƒˆã‚¯ãƒ©ã‚¹ã¯ä»¥ä¸‹ã®æ¡ä»¶ã‚’満ãŸã™å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr "<literal>java.io.Serializable</literal> を実装ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:170
+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> ã‚’å†å®Ÿè£…ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr "注æ„: Hibernate3ã«ãŠã„ã¦ã€2番目ã®æ¡ä»¶ã¯çµ¶å¯¾çš„ãªæ¡ä»¶ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ã—ã‹ã—ã¨ã«ã‹ãæ¡ä»¶ã‚’満ãŸã—ã¦ãã ã•ã„。"
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr "複åˆã‚ーを生æˆã™ã‚‹ãŸã‚ã« <literal>IdentifierGenerator</literal> を使用ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 代ã‚ã‚Šã«ã‚¢ãƒ—リケーションãŒè˜åˆ¥åを割り当ã¦ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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><id></literal> 宣言ã®ä»£ã‚ã‚Šã« <literal><composite-id></literal> ã‚¿ã‚°ã‚’ （ãƒã‚¹ãƒˆã•ã‚ŒãŸ <literal><key-property></literal> 属性ã¨å…±ã«ï¼‰ä½¿ã„ã¾ã™ã€‚ 以下ã®ä¾‹ã§ã¯ã€<literal>OrderLine</literal> クラス㯠<literal>Order</literal> ã®ï¼ˆè¤‡åˆï¼‰ä¸»ã‚ー㫠ä¾å˜ã—ãŸä¸»ã‚ーをæŒã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">
+\n"
+ "
+\n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">
+\n"
+ " <key-property name=\"lineId\"/>
+\n"
+ " <key-property name=\"orderId\"/>
+\n"
+ " <key-property name=\"customerId\"/>
+\n"
+ " </composite-id>
+\n"
+ "
+\n"
+ " <property name=\"name\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"order\" class=\"Order\"
+\n"
+ " insert=\"false\" update=\"false\">
+\n"
+ " <column name=\"orderId\"/>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " </many-to-one>
+\n"
+ " ....
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr "ã“ã®ã¨ãã€<literal>OrderLine</literal> テーブルã¸é–¢é€£ã™ã‚‹å¤–部ã‚ーもã¾ãŸè¤‡åˆã§ã™ã€‚ ä»–ã®ã‚¯ãƒ©ã‚¹ã®ãƒžãƒƒãƒ”ングã§ã“れを宣言ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <literal>OrderLine</literal> ã¸ã®é–¢é€£ã¯æ¬¡ã®ã‚ˆã†ã«ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">
+\n"
+ "<!-- the \"class\" attribute is optional, as usual -->
+\n"
+ " <column name=\"lineId\"/>
+\n"
+ " <column name=\"orderId\"/>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr "（<literal><column></literal> ã‚¿ã‚°ã¯ã©ã“ã§ã‚ã£ã¦ã‚‚ <literal>column</literal> 属性㮠代ã‚ã‚Šã«ãªã‚Šã¾ã™ã€‚）"
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr "<literal>OrderLine</literal> ã¸ã® <literal>many-to-many</literal> 関連も 複åˆå¤–部ã‚ーを使ã„ã¾ã™ã€‚"
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">
+\n"
+ " <key column name=\"warehouseId\"/>
+\n"
+ " <many-to-many class=\"OrderLine\">
+\n"
+ " <column name=\"lineId\"/>
+\n"
+ " <column name=\"orderId\"/>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " </many-to-many>
+\n"
+ "</set>]]>"
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr "<literal>Order</literal> ã«ã‚ã‚‹ <literal>OrderLine</literal> ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ 次ã®ã‚‚ã®ã‚’使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">
+\n"
+ " <key>
+\n"
+ " <column name=\"orderId\"/>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " </key>
+\n"
+ " <one-to-many class=\"OrderLine\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr "（<literal><one-to-many></literal> 属性ã¯ã€ä¾‹ã«ã‚ˆã£ã¦ã‚«ãƒ©ãƒ を宣言ã—ã¾ã›ã‚“）"
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr "<literal>OrderLine</literal> 自身ãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’æŒã£ã¦ã„ã‚‹å ´åˆã€ åŒæ™‚ã«è¤‡åˆå¤–部ã‚ーもæŒã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">
+\n"
+ " ....
+\n"
+ " ....
+\n"
+ " <list name=\"deliveryAttempts\">
+\n"
+ " <key> <!-- a collection inherits the composite key type -->
+\n"
+ " <column name=\"lineId\"/>
+\n"
+ " <column name=\"orderId\"/>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " </key>
+\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>
+\n"
+ " <composite-element class=\"DeliveryAttempt\">
+\n"
+ " ...
+\n"
+ " </composite-element>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr "動的コンãƒãƒ¼ãƒãƒ³ãƒˆ"
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr "<literal>Map</literal> åž‹ã®ãƒ—ãƒãƒ‘ティã®ãƒžãƒƒãƒ”ングもå¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">
+\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>
+\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>
+\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>
+\n"
+ "</dynamic-component>]]>"
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr "<literal><dynamic-component></literal> マッピングã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã¯ <literal><component></literal> ã¨åŒä¸€ã®ã‚‚ã®ã§ã™ã€‚ã“ã®ç¨®ã®ãƒžãƒƒãƒ”ングã®åˆ©ç‚¹ã¯ã€ãƒžãƒƒãƒ”ングドã‚ュメントã®ç·¨é›†ã«ã‚ˆã‚Šã€é…置時ã«beanã®å±žæ€§ã‚’ 決定ã§ãる点ã§ã™ã€‚ã¾ãŸã€DOMパーサを利用ã—ã¦ã€ãƒžãƒƒãƒ”ングドã‚ュメントã®ãƒ©ãƒ³ã‚¿ã‚¤ãƒ æ“作ãŒå¯èƒ½ã§ã™ã€‚ ã•ã‚‰ã«ã€<literal>Configuration</literal> オブジェクト経由ã§Hibernateã®ã‚³ãƒ³ãƒ•ã‚£ã‚°ãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³æ™‚ã®ãƒ¡ã‚¿ãƒ¢ãƒ‡ãƒ«ã« アクセス（ã¾ãŸã¯å¤‰æ›´ï¼‰ãŒå¯èƒ½ã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1599 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr "<title>è¨å®š</title>"
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr "Hibernateã¯ã•ã¾ã–ã¾ãªç’°å¢ƒã§å‹•ä½œã™ã‚‹ã‚ˆã†ã«ãƒ‡ã‚¶ã‚¤ãƒ³ã•ã‚Œã¦ã„ã‚‹ãŸã‚ã€éžå¸¸ã«å¤šãã®è¨å®šè¦ç´ ãŒã‚ã‚Šã¾ã™ã€‚ 幸ã„ãªã“ã¨ã«ã€Hibernateã¯ã€å…¬é–‹ã•ã‚Œã¦ã„るパッケージ㮠<literal>etc/</literal> フォルダ㮠<literal>hibernate.properties</literal> ã«ã€ã»ã¨ã‚“ã©ã®è¨å®šè¦ç´ ã®é©åˆ‡ãªãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ãŒè¨˜è¿°ã•ã‚Œã¦ã„ã¾ã™ã€‚ ã“ã® <literal>hibernate.properties</literal> をクラスパスã«è¨å®šã—ã€è¨å®šè¦ç´ をカスタマイズã™ã‚‹ã ã‘ã§ã™ã€‚"
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr "プãƒã‚°ãƒ©ãƒ 上ã®è¨å®š"
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr "<literal>org.hibernate.cfg.Configuration</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ Javaã®åž‹ã¨SQLデータベースã®ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã‚’ã™ã¹ã¦æŒã£ã¦ã„ã¾ã™ã€‚ The <literal>Configuration</literal> ã¯ã€ï¼ˆä¸å¤‰ã®ï¼‰ <literal>SessionFactory</literal> を生æˆã™ã‚‹ã¨ãã«ä½¿ç”¨ã—ã¾ã™ã€‚ 複数ã®XMLマッピングファイルを変æ›ã—ã€ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr "通常ã€<literal>Configuration</literal> インスタンスã¯ã€ç‰¹å®šã®XMLマッピングファイル ã«ã‚ˆã£ã¦ç›´æŽ¥åˆæœŸåŒ–ã•ã‚Œã¾ã™ã€‚ã‚‚ã—ã€ãƒžãƒƒãƒ”ングファイルãŒã‚¯ãƒ©ã‚¹ãƒ‘スã«è¨å®šã•ã‚Œã¦ã„ã‚‹å ´åˆã€ 次ã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’使ã£ã¦ãã ã•ã„。 <literal>addResource()</literal> :"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr "代替案(ã“ã¡ã‚‰ã®ã»ã†ãŒè‰¯ã„ã¨ãã‚‚ã‚ã‚Šã¾ã™)ã¨ã—ã¦ãƒžãƒƒãƒ”ングクラスを指定ã™ã‚‹æ–¹æ³•ã‚‚ã‚ã‚Šã¾ã™ã€‚Hibernateã«ã€ãƒžãƒƒãƒ”ングファイルを 見ã¤ã‘ã•ã›ã¦ãã ã•ã„："
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr "Hibernateã¯ã€ã‚¯ãƒ©ã‚¹ãƒ‘スã«ã‚る以下ã®ã‚ˆã†ãªåå‰ã®ãƒžãƒƒãƒ”ングファイルを見ã¤ã‘ã¾ã™ã€‚ <literal>/org/hibernate/auction/Item.hbm.xml</literal> 〠<literal>/org/hibernate/auction/Bid.hbm.xml</literal> 。 ã“ã®æ–¹æ³•ã ã¨ã€ãƒãƒ¼ãƒ‰ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°ã•ã‚ŒãŸãƒ•ã‚¡ã‚¤ãƒ«åを排除ã§ãã¾ã™ã€‚"
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr "<literal>Configuration</literal> ã¯ã€è¨å®šãƒ—ãƒãƒ‘ティを指定ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ï¼š"
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr "Hibernateã«è¨å®šãƒ—ãƒãƒ‘ティを通ã™æ–¹æ³•ã¯1ã¤ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ã•ã¾ã–ã¾ãªã‚ªãƒ—ションを用æ„ã—ã¦ã„ã¾ã™ï¼š"
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr "<literal>java.util.Properties</literal> インスタンスを <literal>Configuration.setProperties()</literal> ã«æ¸¡ã—ã¾ã™ã€‚"
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr "<literal>hibernate.properties</literal> ã‚’ クラスパスã®ãƒ«ãƒ¼ãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«ç½®ãã¾ã™ã€‚"
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr "<literal>System</literal> プãƒãƒ‘ティ㌠<literal>java -Dproperty=value</literal> を使ã†ã‚ˆã†ã«è¨å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr "<literal><property></literal> è¦ç´ ã‚’ <literal>hibernate.cfg.xml</literal> （後述）ã«è¨å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr "今ã™ã始ã‚ãŸã„ã®ãªã‚‰ã€<literal>hibernate.properties</literal> を使ã†ã®ãŒä¸€ç•ªã®è¿‘é“ã§ã™ã€‚"
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr "<literal>Configuration</literal> ã¯ã€èµ·å‹•æ™‚ã«ã ã‘ã‚るオブジェクトã§ã‚り〠一度 <literal>SessionFactory</literal> を生æˆã—ãŸå¾Œã¯ã€ç ´æ£„ã•ã‚Œã‚‹ã“ã¨ã‚’æ„図ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr "SessionFactoryã‚’å–å¾—ã™ã‚‹"
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr "<literal>Configuration</literal> ãŒã™ã¹ã¦ã®ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã‚’è§£æžã—ãŸã‚‰ã€ アプリケーションã¯ã€ <literal>Session</literal> ファクトリインスタンスをå–å¾—ã—ã¾ã™ã€‚ ã“ã®SessionFactoryã¯ã€Hibernateを使用ã™ã‚‹ã™ã¹ã¦ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã§å…±æœ‰ã•ã‚Œã‚‹ã¹ãã§ã™ã€‚"
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr "Hibernateã¯ã€ <literal>SessionFactory</literal> を複数生æˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã‚Œã¯ã€è¤‡æ•°ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’使用ã™ã‚‹å ´åˆã«ä¾¿åˆ©ã§ã™ã€‚"
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr "JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr "通常ã€é–‹ç™ºè€…㯠<literal>SessionFactory</literal> を生æˆã—ã€SessionFactoryã§JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’プーリングã—ãŸã„ã¨è€ƒãˆã¾ã™ã€‚ ãã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’採用ã™ã‚‹å ´åˆã€å˜ç´”ã« <literal>Session</literal> をオープンã—ã¦ãã ã•ã„："
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr "ã“ã‚Œã ã‘ã§ã€ãƒ—ーリングã—ãŸJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã£ã¦ç›®çš„ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr "ãã®ãŸã‚ã«ã¯ã€JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã®ãƒ—ãƒãƒ‘ティをHibernateã«è¨å®šã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ã™ã¹ã¦ã®Hibernateプãƒãƒ‘ティåã¨ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã¯ <literal>org.hibernate.cfg.Environment</literal> クラスã«å®šç¾©ã•ã‚Œã¦ã„ã¾ã™ã€‚ ã“ã®è¨å®šã¯JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³è¨å®šã®ä¸ã§ä¸€ç•ªé‡è¦ãªã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr "ã‚‚ã—ã€ä»¥ä¸‹ã®ãƒ—ãƒãƒ‘ティをè¨å®šã™ã‚‹ã¨ã€Hibernateã¯ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å–å¾—ã™ã‚‹ï¼ˆãƒ—ールも）ãŸã‚ã« <literal>java.sql.DriverManager</literal> を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr "Hibernate JDBCプãƒãƒ‘ティ"
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr "プãƒãƒ‘ティå"
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr "<entry>æ„味</entry>"
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr "JDBCドライãƒã‚¯ãƒ©ã‚¹"
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr "jdbc URL"
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:179
+msgid "database user"
+msgstr "database user"
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:187
+msgid "database user password"
+msgstr "database user password"
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr "hibernate.connection.pool_size"
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr "プールã™ã‚‹ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã®æœ€å¤§æ•°"
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr "Hibernateã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールアルゴリズムã¯éžå¸¸ã«åˆæ©çš„ãªã‚‚ã®ã§ã™ã€‚ ã“ã‚Œã¯ã™ãã«å§‹ã‚られるよã†ã«ã¨ç”¨æ„ã•ã‚ŒãŸã‚‚ã®ã§ã€<emphasis>製å“ã¨ã—ã¦ä½¿ç”¨ã™ã‚‹ã“ã¨ã‚’æ„図ã—ã¦ã„ã¾ã›ã‚“</emphasis> 。 ã¾ãŸã€ãƒ‘フォーマンスã®ãƒ†ã‚¹ãƒˆã®ãŸã‚ã®ã‚‚ã®ã§ã‚‚ã‚ã‚Šã¾ã›ã‚“。 最高ã®ãƒ‘フォーマンスã¨å®‰å®šæ€§ã‚’æŒã£ãŸãƒ—ールを実ç¾ã—ãŸã‘ã‚Œã°ã€ã‚µãƒ¼ãƒ‰ãƒ‘ーティã®ãƒ„ールをãŠå‹§ã‚ã—ã¾ã™ã€‚ <literal>hibernate.connection.pool_size</literal> プãƒãƒ‘ティ㫠é©åˆ‡ãªã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールサイズを記述ã—ã¦ãã ã•ã„。 ã“ã®ã¾ã¾ã ã¨Hibernateã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールを使ã„ã¾ã™ã€‚ 例ãˆã°æ¬¡ã®ã‚ˆã†ã«C3P0を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr "C3P0ã¯ã‚ªãƒ¼ãƒ—ンソースJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールã§ã€Hibernateã® <literal>lib</literal> ディレクトリã«ã‚ã‚Šã¾ã™ã€‚ã‚‚ã—ã€<literal>hibernate.c3p0.*</literal> プãƒãƒ‘ティを セットã™ã‚Œã°ã€Hibernateã¯ã€ <literal>C3P0ConnectionProvider</literal> を使ã„ã¾ã™ã€‚ ã‚‚ã—Proxoolを使ã„ãŸã„å ´åˆã¯ã€ <literal>hibernate.properties</literal> パッケージを å‚ç…§ã—ãŸã‚Šã€Hibernateã®Webサイトã§ã‚ˆã‚Šå¤šãã®æƒ…å ±ã‚’å–å¾—ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr "C3P0用㮠<literal>hibernate.properties</literal> ファイルを例ã¨ã—ã¦ç¤ºã—ã¾ã™ï¼š"
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr "アプリケーションサーãƒä¸Šã§ä½¿ã†å ´åˆã¯ã€Hibernateã‚’è¨å®šã—〠アプリケーションサーãƒã‹ã‚‰ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å–å¾—ã™ã‚‹ã‚ˆã†ã«ã—ã¦ãã ã•ã„。 <literal>Datasource</literal> ã‚’JNDIã«ç™»éŒ²ã—ã¾ã™ã€‚ãã—㦠プãƒãƒ‘ティを以下ã®ã‚ˆã†ã«è¨å®šã—ã¦ãã ã•ã„。"
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr "Hibernate データソースプãƒãƒ‘ティ"
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr "hibernate.connection.datasource"
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr "データソースã®JNDIå"
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr "hibernate.jndi.url"
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr "<emphasis>JNDIプãƒãƒã‚¤ãƒ€ã®URL</emphasis> (オプション)"
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr "hibernate.jndi.class"
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr "<emphasis>JNDIクラス <literal>InitialContextFactory</literal> </emphasis> (オプション)"
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr "<emphasis>database user</emphasis> (オプション)"
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr "<emphasis>database user password</emphasis> (オプション)"
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr "アプリケーションサーãƒã‹ã‚‰æä¾›ã•ã‚ŒãŸJNDIデータソースを使ㆠ<literal>hibernate.properties</literal> ファイルã®ä¾‹ã‚’示ã—ã¾ã™ï¼š"
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = ¥\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = ¥\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr "JNDIデータソースã‹ã‚‰å–å¾—ã—ãŸJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã¯ã€ã‚¢ãƒ—リケーションサーãƒã® コンテナ管ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«è‡ªå‹•çš„ã«å‚åŠ ã—ã¾ã™ã€‚"
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr "ä»»æ„ã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティã¯ã€ä¸Žãˆã‚‰ã‚ŒãŸâ€ <literal>hibernate.connnection</literal> †プãƒãƒ‘ティåã«ã‚ˆã£ã¦ä¸Žãˆã‚‰ã‚Œã¾ã™ã€‚例ãˆã°ã€ <literal>charSet</literal> ã‚’è¨å®šã—ãŸã„å ´åˆã¯ã€ <literal>hibernate.connection.charSet</literal> を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr "JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å–å¾—ã™ã‚‹æˆ¦ç•¥ã‚’æŒã¤ç‹¬è‡ªã®ãƒ—ラグインを定義ã™ã‚‹å ´åˆã¯ã€ <literal>org.hibernate.connection.ConnectionProvider</literal> インターフェイスを 実装ã—ã¦ãã ã•ã„。ãã—ã¦ã€å®Ÿè£…クラスを <literal>hibernate.connection.provider_class</literal> ã«è¨å®šã—ã¦ãã ã•ã„。"
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr "オプションè¨å®šãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr "ã“れらã®ãƒ—ãƒãƒ‘ティã¯Hibernateã®æŒ™å‹•ã‚’制御ã™ã‚‹ã‚‚ã®ã§ã™ã€‚ ã“れらã®ãƒ—ãƒãƒ‘ティã¯ã™ã¹ã¦å¦¥å½“ãªãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ãŒã‚ã‚Šã€ä»»æ„ã§è¨å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr "<emphasis>注æ„：ã“れらã®ãƒ—ãƒãƒ‘ティã¯\"システムレベル\"ã®ã¿ã§ã™ã€‚</emphasis> システムレベルプãƒãƒ‘ティ㯠<literal>java -Dproperty=value</literal> ã€ã‚‚ã—ã㯠<literal>hibernate.properties</literal> ã§ã®ã¿è¨å®šå¯èƒ½ã§ã™ã€‚ ãれ以外ã®è¨å®šæ–¹æ³•ã¯ <emphasis>ã‚ã‚Šã¾ã›ã‚“</emphasis> 。"
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr "Hibernateè¨å®šãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr "Hibernate <literal>Dialect</literal> クラスåãŒå…¥ã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã”ã¨ã«æœ€é©åŒ–ã•ã‚ŒãŸSQLを生æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>full.classname.of.Dialect</literal>"
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr "hibernate.show_sql"
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr "発行ã•ã‚ŒãŸã™ã¹ã¦ã®SQLをコンソールã«å‡ºåŠ›ã—ã¾ã™ã€‚ ã“ã‚Œã¯ãƒã‚°ã‚«ãƒ†ã‚´ãƒªã® <literal>org.hibernate.SQL</literal> ã« <literal>debug</literal> ã‚’è¨å®šã™ã‚‹æ–¹æ³•ã®ä»£æ›¿æ‰‹æ®µã§ã™ã€‚"
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr "hibernate.format_sql"
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr "ãƒã‚°ã¨ã‚³ãƒ³ã‚½ãƒ¼ãƒ«ã®SQLを美ã—ã表示ã—ã¾ã™ã€‚"
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr "hibernate.default_schema"
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr "生æˆã•ã‚Œã‚‹SQLæ–‡ã®ãƒ†ãƒ¼ãƒ–ルã«è¨å®šã™ã‚‹ã‚¹ã‚ーマ/テーブルスペースã§ã™ã€‚"
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>SCHEMA_NAME</literal>"
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr "hibernate.default_catalog"
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr "生æˆã•ã‚Œã‚‹SQLæ–‡ã®ãƒ†ãƒ¼ãƒ–ルã«è¨å®šã™ã‚‹ã‚«ã‚¿ãƒã‚°ã§ã™ã€‚"
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>CATALOG_NAME</literal>"
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr "hibernate.session_factory_name"
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr "<literal>SessionFactory</literal> ã¯ç”Ÿæˆå¾Œã€ã“ã®åå‰ã§JNDIã«ç™»éŒ²ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>jndi/composite/name</literal>"
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr "hibernate.max_fetch_depth"
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr "外部çµåˆãƒ•ã‚§ãƒƒãƒã®æœ€å¤§æ·±åº¦ã‚’è¨å®šã—ã¾ã™ã€‚çµåˆã™ã‚‹é–¢é€£ã¯ 対一関連ã®ã¿ï¼ˆä¸€å¯¾ä¸€ã€å¤šå¯¾ä¸€ï¼‰ã§ã™ã€‚ <literal>0</literal> を指定ã™ã‚‹ã¨å¤–部çµåˆãƒ•ã‚§ãƒƒãƒã¯ç„¡åŠ¹ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> 推奨ã™ã‚‹å€¤ã¯ <literal>0</literal> ã‹ã‚‰ <literal>3</literal> ã§ã™ã€‚"
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr "hibernate.default_batch_fetch_size"
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr "関連フェッãƒã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆãƒãƒƒãƒã‚µã‚¤ã‚ºã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> 推奨ã™ã‚‹å€¤ã¯ <literal>4</literal> , <literal>8</literal> , <literal>16</literal> ã§ã™ã€‚"
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr "hibernate.default_entity_mode"
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr "<literal>SessionFactory</literal> ã‹ã‚‰ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚’オープンã—ãŸã¨ã㫠使用ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆãƒ¢ãƒ¼ãƒ‰ã‚’è¨å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr "hibernate.order_updates"
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr "é …ç›®ãŒæ›´æ–°ã•ã‚ŒãŸã¨ãã«ã€åˆ¥ã®SQLã§ä¸»ã‚ーを更新ã™ã‚‹ã“ã¨ã‚’強制ã—ã¾ã™ã€‚ ã“ã®å ´åˆã€åŒæ™‚実行å¯èƒ½ãªã‚·ã‚¹ãƒ†ãƒ ã§ã¯ã€ã¾ã‚Œã«ãƒ‡ãƒƒãƒ‰ãƒãƒƒã‚¯ãŒç™ºç”Ÿã™ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr "hibernate.generate_statistics"
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr "有効ã®å ´åˆã€Hibernateã¯ãƒ‘フォーマンスãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã« 有効ãªçµ±è¨ˆæƒ…å ±ã‚’åŽé›†ã—ã¾ã™ã€‚"
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr "hibernate.use_identifer_rollback"
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr "有効ã®å ´åˆã€ã‚ªãƒ–ジェクトãŒå‰Šé™¤ã•ã‚ŒãŸã¨ãã« è˜åˆ¥åプãƒãƒ‘ティをリセットã—ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã«ã—ãŸã‚‚ã®ã‚’生æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr "hibernate.use_sql_comments"
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr "有効ã®å ´åˆã€SQL内ã«ã‚³ãƒ¡ãƒ³ãƒˆã‚’生æˆã—ã¾ã™ã€‚ã“ã‚Œã¯ãƒ‡ãƒãƒƒã‚¯ã‚’容易ã«ã—ã¾ã™ã€‚ デフォルトã®å€¤ã¯ <literal>false</literal> ã§ã™ã€‚"
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr "Hibernate JDBC ã¨ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr "hibernate.jdbc.fetch_size"
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr "値ãŒ0ã§ãªã„å ´åˆã€JDBCフェッãƒã‚µã‚¤ã‚ºã‚’決定ã—ã¾ã™ ( <literal>Statement.setFetchSize()</literal> を呼ã³ã¾ã™)。"
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr "hibernate.jdbc.batch_size"
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr "値ãŒ0ã§ãªã„å ´åˆã€HibernateãŒJDBC2ãƒãƒƒãƒæ›´æ–°ã‚’使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> 推奨ã™ã‚‹å€¤ã¯ <literal>5</literal> ã‹ã‚‰ <literal>30</literal> ã§ã™ã€‚"
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr "hibernate.jdbc.batch_versioned_data"
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr "ã‚‚ã—JDBCドライãƒãŒ <literal>executeBatch()</literal> ã«ã‚ˆã£ã¦æ£ç¢ºãªè¡Œæ•°ã‚’ è¿”ã™å ´åˆã€ã“ã®ãƒ—ãƒãƒ‘ティを <literal>true</literal> ã«ã—ã¦ãã ã•ã„ （通常ã¯ã“ã®ã‚ªãƒ—ションをONã«ã—ã¾ã™ï¼‰ã€‚ Hibernateã¯ã€è‡ªå‹•ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ‡ãƒ¼ã‚¿ã®ãŸã‚ãƒãƒƒãƒDMLを使ã„ã¾ã™ã€‚ デフォルトã®å€¤ã¯ <literal>false</literal> ã§ã™ã€‚"
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr "hibernate.jdbc.factory_class"
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr "カスタム<literal>Batcher</literal> ã‚’é¸ã³ã¾ã™ã€‚ ã»ã¨ã‚“ã©ã®ã‚¢ãƒ—リケーションã«ã€ã“ã®è¨å®šã¯å¿…è¦ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.BatcherFactory</literal>"
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr "hibernate.jdbc.use_scrollable_resultset"
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr "スクãƒãƒ¼ãƒ«å¯èƒ½ãªãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’ã€HibernateãŒä½¿ç”¨ã—ã¾ã™ã€‚ ã“ã®ãƒ—ãƒãƒ‘ティã¯ã€JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãŒã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’ サãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹ã“ã¨ãŒå¿…é ˆæ¡ä»¶ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr "hibernate.jdbc.use_streams_for_binary"
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr "JDBCã¸/ã‹ã‚‰ <literal>binary</literal> ã‚„ <literal>serializable</literal> ã®æ›¸ãè¾¼ã¿/èªã¿è¾¼ã¿ã‚¹ãƒˆãƒªãƒ¼ãƒ を使ã„ã¾ã™(システムレベルã®ãƒ—ãƒãƒ‘ティ)。"
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr "hibernate.jdbc.use_get_generated_keys"
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr "挿入ã®å¾Œã«è‡ªå‹•ç”Ÿæˆã•ã‚ŒãŸä¸»ã‚ーをå–å¾—ã™ã‚‹ãŸã‚ã® JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> ã®ä½¿ç”¨ã‚’有効ã«ã—ã¾ã™ã€‚ ã“ã‚Œã¯JDBC3+ドライãƒã¨JRE1.4+ã‚’å¿…è¦ã¨ã—〠もã—Hibernateã®è˜åˆ¥åジェãƒãƒ¬ãƒ¼ã‚¿ã«å•é¡ŒãŒç™ºç”Ÿã™ã‚‹ã‚ˆã†ãªã‚‰falseã«è¨å®šã—ã¦ãã ã•ã„。 デフォルトã§ã¯ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’使ã„ドライãƒã®èƒ½åŠ›ã‚’決定ã—ã¾ã™ã€‚"
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr "hibernate.connection.provider_class"
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr "JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’Hibernateã«æä¾›ã™ã‚‹ç‹¬è‡ªã® <literal>ConnectionProvider</literal> ã® åå‰ã‚’指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr "hibernate.connection.isolation"
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr "JDBCトランザクション分離レベルをè¨å®šã—ã¾ã™ã€‚ 妥当ãªå€¤ã‚’調ã¹ã‚‹ãŸã‚ã«ã¯ <literal>java.sql.Connection</literal> ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¦ãã ã•ã„。 ã—ã‹ã—使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒã€ã™ã¹ã¦ã®åˆ†é›¢ãƒ¬ãƒ™ãƒ«ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹ã¨ã¯é™ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>1, 2, 4, 8</literal>"
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr "hibernate.connection.autocommit"
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr "プールã•ã‚Œã¦ã„ã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã®è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆã‚’有効ã«ã™ã‚‹ï¼ˆéžæŽ¨å¥¨ï¼‰ã€‚"
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr "hibernate.connection.release_mode"
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr "HibernateãŒJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’リリースã™ã‚‹ã‹ã‚’指定ã—ã¾ã™ã€‚デフォルトã§ã¯ セッションãŒæ˜Žç¤ºçš„ã«ã‚¯ãƒãƒ¼ã‚ºã¾ãŸã¯åˆ‡æ–ã•ã‚Œã¦ã‚‚コãƒã‚¯ã‚·ãƒ§ãƒ³ã¯ä¿æŒã—ã¾ã™ã€‚ アプリケーションサーãƒã®JTAデータソースã®å ´åˆã€ ã™ã¹ã¦ã®JDBCコールã®å¾Œã€å¼·åˆ¶çš„ã«ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’リリースã™ã‚‹ãŸã‚ã« <literal>after_statement</literal> ã‚’ 使ã£ã¦ãã ã•ã„。 éžJTAコãƒã‚¯ã‚·ãƒ§ãƒ³ã®å ´åˆã€å„トランザクションãŒçµ‚了ã—ãŸã¨ãã« <literal>after_transaction</literal> を使ã„ã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’リリースã—ã¦ãã ã•ã„。 <literal>auto</literal> ã«ã™ã‚‹ã¨ã€ JTAã‚„CMTトランザクションã®å ´åˆã€ <literal>after_statement</literal> ã§ã‚¯ãƒãƒ¼ã‚ºã—〠JDBCトランザクションã®å ´åˆã€ <literal>after_transaction</literal> ã§ã‚¯ãƒãƒ¼ã‚ºã—ã¾ã™ã€‚"
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr "注æ„ã—ã¦ãã ã•ã„。ã“ã®è¨å®šã¯ <literal>SessionFactory.openSession</literal> ã‹ã‚‰ å–å¾—ã—㟠<literal>Session</literal> ã ã‘ã«åŠ¹æžœãŒã‚ã‚Šã¾ã™ã€‚ <literal>SessionFactory.getCurrentSession</literal> を通ã˜ã¦å–å¾—ã—㟠<literal>Session</literal> ã§ã¯ã€<literal>CurrentSessionContext</literal> ã®å®Ÿè£…ã«ã‚ˆã£ã¦ã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã®ãƒªãƒªãƒ¼ã‚¹ãƒ¢ãƒ¼ãƒ‰ã‚’è¨å®šã—ã¾ã™ã€‚ <xref linkend=\"architecture-current-session\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr "hibernate.connection.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr "JDBCã® <literal>propertyName</literal> プãƒãƒ‘ティを〠<literal>DriverManager.getConnection()</literal> ã«æ¸¡ã—ã¾ã™ã€‚"
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr "hibernate.jndi.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr "<literal>propertyName</literal> プãƒãƒ‘ティを〠JNDI <literal>InitialContextFactory</literal> ã«æ¸¡ã—ã¾ã™ã€‚"
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr "Hibernate ã‚ャッシュプãƒãƒ‘ティ"
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr "hibernate.cache.provider_class"
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr "カスタム<literal>CacheProvider</literal> ã®ã‚¯ãƒ©ã‚¹åã§ã™ã€‚"
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.CacheProvider</literal>"
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr "hibernate.cache.use_minimal_puts"
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr "書ãè¾¼ã¿ã‚’最å°é™ã«ã™ã‚‹ãŸã‚ã«ã€äºŒæ¬¡ã‚ャッシュã®æ“作を最é©åŒ–ã—ã¾ã™ã€‚ ãã®ä»£ã‚ã‚Šã«ã€èªã¿è¾¼ã¿ãŒã‚ˆã‚Šé »ç¹ã«ç™ºç”Ÿã™ã‚‹ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚ ã“ã®ã‚»ãƒƒãƒ†ã‚£ãƒ³ã‚°ã¯ã‚¯ãƒ©ã‚¹ã‚¿ã‚ャッシュã§å½¹ã«ç«‹ã¡ã¾ã™ã€‚ Hibernate3ã§ã¯ã‚¯ãƒ©ã‚¹ã‚¿ã‚ャッシュ実装用ã«ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯æœ‰åŠ¹ã«ãªã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr "hibernate.cache.use_query_cache"
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr "特定ã®ã‚¯ã‚¨ãƒªãŒã‚ャッシュå¯èƒ½ãªå ´åˆã«ã€ã‚¯ã‚¨ãƒªã‚ャッシュを有効ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr "hibernate.cache.use_second_level_cache"
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr "二次ã‚ャッシュを完全ã«ç„¡åŠ¹ã«ã™ã‚‹å ´åˆã«ä½¿ã„ã¾ã™ã€‚ デフォルトã§ã¯æœ‰åŠ¹ã§ã€ã‚¯ãƒ©ã‚¹ã® <literal><cache></literal> マッピング ã§åˆ¶å¾¡ã—ã¾ã™ã€‚"
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr "hibernate.cache.query_cache_factory"
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr "カスタム<literal>QueryCache</literal> インターフェイスã®ã‚¯ãƒ©ã‚¹åã‚’ 指定ã—ã¾ã™ã€‚デフォルトã§ã¯ <literal>StandardQueryCache</literal> ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.QueryCache</literal>"
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr "hibernate.cache.region_prefix"
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr "二次ã‚ャッシュã®é ˜åŸŸåã®æŽ¥é 辞ã§ã™ã€‚"
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>prefix</literal>"
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr "hibernate.cache.use_structured_entries"
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr "二次ã‚ャッシュã«æ ¼ç´ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ã‚’ã€äººãŒç†è§£ã—ã‚„ã™ã„フォーマットã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr "Hibernate トランザクションプãƒãƒ‘ティ"
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr "hibernate.transaction.factory_class"
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr "Hibernate <literal>Transaction</literal> APIã¨ä¸€ç·’ã«ä½¿ã‚れる <literal>TransactionFactory</literal> ã®ã‚¯ãƒ©ã‚¹åã§ã™ã€‚ （デフォルトã§ã¯ <literal>JDBCTransactionFactory</literal> ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.TransactionFactory</literal>"
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr "jta.UserTransaction"
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr "アプリケーションサーãƒã‹ã‚‰JTA <literal>UserTransaction</literal> ã‚’å–å¾—ã™ã‚‹ãŸã‚ã« <literal>JTATransactionFactory</literal> ã«ä½¿ã‚れるJNDIåã§ã™ã€‚"
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr "hibernate.transaction.manager_lookup_class"
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr "<literal>TransactionManagerLookup</literal> ã®ã‚¯ãƒ©ã‚¹åã§ã™ã€‚ JTA環境ã«ãŠã„ã¦ã€JVMレベルã®ã‚ャッシュを有効ã«ã™ã‚‹ãŸã‚ã«å¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr "hibernate.transaction.flush_before_completion"
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "有効ã®å ´åˆã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®completionフェーズã®å‰ã«è‡ªå‹•çš„㫠セッションをフラッシュã—ã¾ã™ã€‚内臓ã®è‡ªå‹•ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚³ãƒ³ãƒ†ã‚スト管ç†ã«é©ã—ã¦ã„ã¾ã™ã€‚ <xref linkend=\"architecture-current-session\"/>ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr "hibernate.transaction.auto_close_session"
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "有効ã®å ´åˆã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®completionフェーズã®å¾Œã« セッションを自動的ã«ã‚¯ãƒãƒ¼ã‚ºã—ã¾ã™ã€‚内臓ã®è‡ªå‹•ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚³ãƒ³ãƒ†ã‚スト管ç†ã«é©ã—ã¦ã„ã¾ã™ã€‚ <xref linkend=\"architecture-current-session\"/>ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr "ãã®ä»–ã®ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr "hibernate.current_session_context_class"
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr "「ç¾åœ¨ã®ã€<literal>Session</literal> ã®ãŸã‚ã®ï¼ˆã‚«ã‚¹ã‚¿ãƒ ）戦略をæä¾›ã—ã¾ã™ã€‚ ビルトインストラテジーã«é–¢ã™ã‚‹ãã®ä»–ã®æƒ…å ±ã«ã¤ã„ã¦ã¯ <xref linkend=\"architecture-current-session\"/>ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr "hibernate.query.factory_class"
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr "HQLパーサーã®å®Ÿè£…ã‚’é¸æŠžã—ã¾ã™ã€‚"
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr "hibernate.query.substitutions"
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr "HQLã¨SQLã®ãƒˆãƒ¼ã‚¯ãƒ³ã‚’マッピングã—ã¾ã™ã€‚ （例ãˆã°ã€ãƒˆãƒ¼ã‚¯ãƒ³ã¯é–¢æ•°ã‚„リテラルåã§ã™ï¼‰ã€‚"
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr "hibernate.hbm2ddl.auto"
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr "<literal>SessionFactory</literal> を生æˆã—ãŸã¨ãã«ã€ 自動的ã«ã‚¹ã‚ーマDDLã‚’DBã«å‡ºåŠ›ã—ã¾ã™ã€‚ <literal>create-drop</literal> ã®å ´åˆã€ <literal>SessionFactory</literal> ã‚’ クãƒãƒ¼ã‚ºã—ãŸã¨ãã«ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマをドãƒãƒƒãƒ—ã—ã¾ã™ã€‚"
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr "<emphasis role=\"strong\">例：</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr "hibernate.cglib.use_reflection_optimizer"
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr "実行時リフレクションã®ä»£ã‚ã‚Šã®CGLIBã®ä½¿ç”¨ã‚’有効ã«ã—ã¾ã™ （システムレベルã®ãƒ—ãƒãƒ‘ティ） リフレクションã¯ãƒˆãƒ©ãƒ–ルシューティングã®ã¨ãã«å½¹ç«‹ã¤ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ オプティマイザをオフã«ã—ã¦ã„ã‚‹ã¨ãã§ã•ãˆã€ Hibernateã«ã¯å¿…ãšCGLIBãŒå¿…è¦ãªã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã®ãƒ—ãƒãƒ‘ティ㯠<literal>hibernate.cfg.xml</literal> ã§è¨å®šã§ãã¾ã›ã‚“。"
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr "SQL 方言（Dialect）"
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr "<literal>hibernate.dialect</literal> プãƒãƒ‘ティã«ã¯ã€ 使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®æ£ã—ã„ <literal>org.hibernate.dialect.Dialect</literal> ã®ã‚µãƒ–クラスを〠必ãšæŒ‡å®šã™ã¹ãã§ã™ã€‚ ã—ã‹ã—方言を指定ã™ã‚Œã°ã€Hibernateã¯ä¸Šè¿°ã—ãŸãƒ—ãƒãƒ‘ティã®ã„ãã¤ã‹ã«ã¤ã„ã¦ã€ よりé©åˆ‡ãªãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã‚’使ã„ã¾ã™ã€‚ ãã†ã™ã‚Œã°ã€ãれらを手作æ¥ã§è¨å®šã™ã‚‹æ‰‹é–“ãŒçœã‘ã¾ã™ã€‚"
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr "RDBMS"
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr "Dialect"
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr "<entry>DB2</entry>"
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr "org.hibernate.dialect.DB2Dialect"
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr "DB2 AS/400"
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr "org.hibernate.dialect.DB2400Dialect"
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr "DB2 OS390"
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr "org.hibernate.dialect.DB2390Dialect"
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr "PostgreSQL"
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr "org.hibernate.dialect.PostgreSQLDialect"
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr "MySQL"
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr "org.hibernate.dialect.MySQLDialect"
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr "MySQL with InnoDB"
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr "org.hibernate.dialect.MySQLInnoDBDialect"
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr "MySQL with MyISAM"
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr "org.hibernate.dialect.MySQLMyISAMDialect"
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr "Oracle (any version)"
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr "org.hibernate.dialect.OracleDialect"
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr "Oracle 9i/10g"
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr "org.hibernate.dialect.Oracle9Dialect"
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr "Sybase"
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr "org.hibernate.dialect.SybaseDialect"
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr "Sybase Anywhere"
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr "org.hibernate.dialect.SybaseAnywhereDialect"
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr "Microsoft SQL Server"
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr "org.hibernate.dialect.SQLServerDialect"
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr "SAP DB"
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr "org.hibernate.dialect.SAPDBDialect"
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr "Informix"
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr "org.hibernate.dialect.InformixDialect"
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr "HypersonicSQL"
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr "org.hibernate.dialect.HSQLDialect"
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr "Ingres"
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr "org.hibernate.dialect.IngresDialect"
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr "Progress"
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr "org.hibernate.dialect.ProgressDialect"
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr "Mckoi SQL"
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr "org.hibernate.dialect.MckoiDialect"
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr "Interbase"
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr "org.hibernate.dialect.InterbaseDialect"
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr "Pointbase"
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr "org.hibernate.dialect.PointbaseDialect"
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr "FrontBase"
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr "org.hibernate.dialect.FrontbaseDialect"
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr "Firebird"
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr "org.hibernate.dialect.FirebirdDialect"
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr "外部çµåˆãƒ•ã‚§ãƒƒãƒ"
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr "ã‚‚ã—DBãŒANSIã‹ã€Oracleã‹Sybaseスタイルã®å¤–部çµåˆã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹å ´åˆã€ <emphasis>outer join fetching</emphasis> ã¯ã€DBã®SQL発行回数を節約㗠パフォーマンスを良ãã—ã¾ã™ã€‚（DB内ã§ã‚ˆã‚Šå¤šãã®å‡¦ç†ã‚³ã‚¹ãƒˆãŒç™ºç”Ÿã—ã¾ã™ï¼‰ 外部çµåˆãƒ•ã‚§ãƒƒãƒã¯ã€å¤šå¯¾ä¸€ã€ä¸€å¯¾å¤šã€å¤šå¯¾å¤šã€ä¸€å¯¾ä¸€ã®ã‚ªãƒ–ジェクト関連㧠グループオブジェクトを1ã¤ã®SQL㧠<literal>SELECT</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr "<literal>hibernate.max_fetch_depth</literal> プãƒãƒ‘ティã®å€¤ã‚’ <literal>0</literal> ã«ã™ã‚‹ã¨ Outer join fetchingã‚’ <emphasis>ã™ã¹ã¦</emphasis> 無効ã«ã™ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ <literal>1</literal> ã‚„ãれ以上ã®å€¤ã‚’è¨å®šã™ã‚‹ã¨ã€å¤–部çµåˆãƒ•ã‚§ãƒƒãƒãŒæœ‰åŠ¹ã«ãªã‚Šã€ 一対一ã¨å¤šå¯¾ä¸€é–¢é€£ãŒ <literal>fetch=\"join\"</literal> ã¨ã—ã¦ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "See <xref linkend=\"performance-fetching\"/> for more information."
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr "ãƒã‚¤ãƒŠãƒªã‚¹ãƒˆãƒªãƒ¼ãƒ "
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr "Oracleã¯JDBCドライãƒã¨ã®é–“ã§ã‚„ã‚Šã¨ã‚Šã•ã‚Œã‚‹ <literal>byte</literal> é…列ã®ã‚µã‚¤ã‚ºã‚’制é™ã—ã¾ã™ã€‚ <literal>binary</literal> ã‚„ <literal>serializable</literal> åž‹ã®å¤§ããªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’使ã„ãŸã‘ã‚Œã°ã€ <literal>hibernate.jdbc.use_streams_for_binary</literal> を有効ã«ã—ã¦ãã ã•ã„。 ãŸã ã— <emphasis>ã“ã‚Œã¯ã‚·ã‚¹ãƒ†ãƒ レベルã®è¨å®šã ã‘ã§ã™</emphasis> 。"
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr "2次ã‚ャッシュã¨ã‚¯ã‚¨ãƒªãƒ¼ã‚ャッシュ"
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr "<literal>hibernate.cache</literal> プãƒãƒ‘ティ接é 辞㯠Hibernateã§ãƒ—ãƒã‚»ã‚¹ã‚„クラスタ二次ã‚ャッシュを使ã†ã¨ã“ã¨ã‚’許å¯ã—ã¾ã™ã€‚ <xref linkend=\"performance-cache\"/>ã«ã‚ˆã‚Šå¤šãã®è©³ç´°ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr "クエリー言語ã®ç½®ãæ›ãˆ"
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr "<literal>hibernate.query.substitutions</literal> を使ã†ã“ã¨ã§ã€ æ–°ã—ã„Hibernateクエリトークンを定義ã§ãã¾ã™ã€‚ 例："
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr "hibernate.query.substitutions true=1, false=0"
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr "ã“ã‚Œã¯ãƒˆãƒ¼ã‚¯ãƒ³ <literal>true</literal> 㨠<literal>false</literal> を〠生æˆã•ã‚Œã‚‹SQLã«ãŠã„ã¦æ•´æ•°ãƒªãƒ†ãƒ©ãƒ«ã«ç¿»è¨³ã—ã¾ã™ã€‚"
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr "hibernate.query.substitutions toLowercase=LOWER"
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr "ã“ã‚Œã¯SQLã® <literal>LOWER</literal> 関数ã®åå‰ã®ä»˜ã‘替ãˆã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr "Hibernate 統計"
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr "<literal>hibernate.generate_statistics</literal> を有効ã«ã—ãŸå ´åˆã€ 動作ã—ã¦ã„るシステムをãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã™ã‚‹ã¨ãã«ã€<literal>SessionFactory.getStatistics()</literal> を経由ã—ã¦ã€Hibernateã¯ä¾¿åˆ©ãªçµ±è¨ˆæƒ…å ±ã‚’å‡ºåŠ›ã—ã¾ã™ã€‚ JMXを経由ã—ã¦çµ±è¨ˆæƒ…å ±ã‚’å‡ºåŠ›ã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚ Javadocã® <literal>org.hibernate.stats</literal> パッケージ内㮠インターフェイスã«ã¯ã‚ˆã‚Šå¤šãã®æƒ…å ±ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr "ãƒã‚®ãƒ³ã‚°"
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr "Hibernateã¯Apache commons-logginを使ã£ã¦ã€ã•ã¾ã–ã¾ãªã‚¤ãƒ™ãƒ³ãƒˆã‚’ãƒã‚°ã¨ã—㦠出力ã—ã¾ã™ã€‚"
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr "commons-loggingサービスã¯ï¼ˆã‚¯ãƒ©ã‚¹ãƒ‘ス㫠<literal>log4j.jar</literal> ã‚’å«ã‚ã‚Œã°ï¼‰Apache Log4jã«ã€ ã¾ãŸï¼ˆJDK1.4ã‹ãれ以上ã§å®Ÿè¡Œã•ã›ã‚Œã°ï¼‰JDK1.4 loggingã«ç›´æŽ¥å‡ºåŠ›ã—ã¾ã™ã€‚ Log4j㯠<literal>http://jakarta.apache.org</literal> ã‹ã‚‰ãƒ€ã‚¦ãƒ³ãƒãƒ¼ãƒ‰ã§ãã¾ã™ã€‚ Log4jを使ã†ãŸã‚ã«ã¯ã€ã‚¯ãƒ©ã‚¹ãƒ‘ス㫠<literal>log4j.properties</literal> ファイルをé…ç½®ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ 例ã®ãƒ—ãƒãƒ‘ティファイルã¯Hibernateã¨ä¸€ç·’ã«é…布ã•ã‚Œã€ãれ㯠<literal>src/</literal> ディレクトリã«ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr "Hibernateã®ãƒã‚°ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã«æ…£ã‚Œã‚‹ã“ã¨ã‚’å¼·ããŠã™ã™ã‚ã—ã¾ã™ã€‚ Hibernateã®ãƒã‚°ã¯èªã¿ã‚„ã™ãã€ã§ãã‚‹é™ã‚Šè©³ç´°ã«ãªã‚‹ã‚ˆã†ã«åŠªåŠ›ã•ã‚Œã¦ã„ã¾ã™ã€‚ ã“ã‚Œã¯å¿…é ˆã®ãƒˆãƒ©ãƒ–ルシューティングデãƒã‚¤ã‚¹ã§ã™ã€‚ 以下ã«é‡è¦ãªãƒã‚°ã®ã‚«ãƒ†ã‚´ãƒªã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr "Hibernate ãƒã‚°ã‚«ãƒ†ã‚´ãƒª"
+
+#: index.docbook:1219
+msgid "Category"
+msgstr "カテゴリ"
+
+#: index.docbook:1220
+msgid "Function"
+msgstr "<entry>機能</entry>"
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr "org.hibernate.SQL"
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr "実行ã—ãŸã™ã¹ã¦ã®SQL（DDL）ステートメントをãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr "org.hibernate.type"
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr "ã™ã¹ã¦ã®JDBCパラメータをãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr "org.hibernate.tool.hbm2ddl"
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr "実行ã—ãŸã™ã¹ã¦ã®SQL（DDL）ステートメントをãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr "org.hibernate.pretty"
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr "sessionã«é–¢é€£ã™ã‚‹ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ï¼ˆæœ€å¤§ï¼’ï¼ï¼‰ã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥æ™‚é–“ã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr "org.hibernate.cache"
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr "ã™ã¹ã¦ã®ï¼’次ã‚ャッシュã®å‹•ä½œã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr "org.hibernate.transaction"
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr "トランザクションã«é–¢é€£ã™ã‚‹å‹•ä½œã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr "org.hibernate.jdbc"
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr "JDBCリソースå–å¾—ã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr "org.hibernate.hql.ast.AST"
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr "HQLã¨SQLã®ASTã®ã‚¯ã‚¨ãƒªãƒ¼ãƒ‘ースをãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr "org.hibernate.secure"
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr "ã™ã¹ã¦ã®JAAS分æžã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚"
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr "org.hibernate"
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr "ã™ã¹ã¦ã‚’ãƒã‚®ãƒ³ã‚°ã—ã¾ã™ã€‚ï¼ˆæƒ…å ±ãŒå¤§é‡ã«ãªã‚Šã¾ã™ãŒã€ãƒˆãƒ©ãƒ–ルシューティングã«ã¯ä¾¿åˆ©ã§ã™ï¼‰"
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr "Hibernateã§ã‚¢ãƒ—リケーションを作æˆã™ã‚‹ã¨ãã¯ã€<literal>org.hibernate.SQL</literal> カテゴリ㮠<literal>debug</literal> を常ã«æœ‰åŠ¹ã«ã—ã¦ãŠã„ãŸã»ã†ãŒè‰¯ã„ã§ã—ょã†ã€‚ 代替方法ã¨ã—ã¦ã€<literal>hibernate.show_sql</literal> を有効ã«ã™ã‚‹æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr "<literal>NamingStrategy</literal> ã®å®Ÿè£…"
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr "インターフェイス <literal>net.sf.hibernate.cfg.NamingStrategy</literal> を使ã†ã¨ データベースオブジェクトã¨ã‚¹ã‚ーマè¦ç´ ã®ãŸã‚ã®ã€Œå‘½å標準ã€ã‚’指定ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr "Javaã®è˜åˆ¥åã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®è˜åˆ¥åを自動生æˆã™ã‚‹ãŸã‚ã®ãƒ«ãƒ¼ãƒ«ã‚„〠マッピングファイルã§ä¸ŽãˆãŸã€Œè«–ç†çš„ãªã€ã‚«ãƒ©ãƒ ã¨ãƒ†ãƒ¼ãƒ–ルåã‹ã‚‰ 「物ç†çš„ãªã€ãƒ†ãƒ¼ãƒ–ルã¨ã‚«ãƒ©ãƒ åを生æˆã™ã‚‹ãŸã‚ã®ãƒ«ãƒ¼ãƒ«ã‚’用æ„ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã®æ©Ÿèƒ½ã¯ç¹°ã‚Šè¿”ã—ã®é›‘音（例ãˆã° <literal>TBL_</literal> プリフィックス）をå–り除ã〠マッピングドã‚ュメントã®å†—é•·ã•ã‚’減らã™ã“ã¨ã«å½¹ç«‹ã¡ã¾ã™ã€‚ HibernateãŒä½¿ã†ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®æˆ¦ç•¥ã¯ã‹ãªã‚Šæœ€å°é™ã«è¿‘ã„ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr "ãƒžãƒƒãƒ”ãƒ³ã‚°ã‚’è¿½åŠ ã™ã‚‹å‰ã« <literal>Configuration.setNamingStrategy()</literal> を呼ã¶ã“ã¨ã§ 以下ã®ã‚ˆã†ã«ç•°ãªã‚‹æˆ¦ç•¥ã‚’指定ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ï¼š"
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> ã¯çµ„ã¿è¾¼ã¿ã®æˆ¦ç•¥ã§ã™ã€‚ ã“ã‚Œã¯ã„ãã¤ã‹ã®ã‚¢ãƒ—リケーションã«ã¨ã£ã¦æœ‰ç”¨ãªé–‹å§‹ç‚¹ã¨ãªã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr "XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«"
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr "ã‚‚ã†1ã¤ã®æ–¹æ³•ã¯ <literal>hibernate.cfg.xml</literal> ã¨ã„ã†åå‰ã®ãƒ•ã‚¡ã‚¤ãƒ«ã§ å分ãªè¨å®šã‚’指定ã™ã‚‹æ–¹æ³•ã§ã™ã€‚ ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã¯ <literal>hibernate.properties</literal> ファイルã®ä»£ã‚ã‚Šã¨ãªã‚Šã¾ã™ã€‚ ã‚‚ã—両方ã®ãƒ•ã‚¡ã‚¤ãƒ«ãŒã‚ã‚Œã°ã€ãƒ—ãƒãƒ‘ティãŒç½®ãæ›ãˆã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr "XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã¯åˆæœŸè¨å®šã§ <literal>CLASSPATH</literal> ã«é…ç½®ã—ã¦ãã ã•ã„。 ã“ã‚ŒãŒä¾‹ã§ã™ï¼š"
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <!-- /jndi/nameã®ã‚ˆã†ã«ãƒªã‚¹ãƒˆã‚¢ãƒƒãƒ—ã•ã‚ŒãŸSessionFactoryインスタンス -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr "見ã¦ã®ã¨ãŠã‚Šã€ã“ã®æ–¹æ³•ã®å„ªä½æ€§ã¯è¨å®šã®ãŸã‚ã®ãƒžãƒƒãƒ”ングファイルåを外出ã—ã«ã§ãã‚‹ã“ã¨ã§ã™ã€‚ Hibernateã‚ャッシュをãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ã®ã§ã‚ã‚Œã°ã€ <literal>hibernate.cfg.xml</literal> ã¯ã‚ˆã‚Šä¾¿åˆ©ã§ã™ã€‚ <literal>hibernate.properties</literal> 㨠<literal>hibernate.cfg.xml</literal> ã® ã©ã¡ã‚‰ã‹ã‚’使ãˆã‚‹ã“ã¨ã‚’覚ãˆã¦ãŠã„ã¦ãã ã•ã„。 二ã¤ã¯åŒã˜ã‚‚ã®ã§ã€é•ã†ã¨ã“ã‚ã¨ã„ãˆã°XML構文を使ã†ã“ã¨ã®åˆ©ç‚¹ã ã‘ã§ã™ã€‚"
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr "XMLè¨å®šã‚’使ã†ã“ã¨ã§ã€Hibernateã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ã‚·ãƒ³ãƒ—ルã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr "é•ã†XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã‚’使ã†ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr "J2EEアプリケーションサーãƒã¨ã®çµ±åˆ"
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr "Hibernateã¯J2EEæ§‹é€ ã¨çµ±åˆã™ã‚‹ãƒã‚¤ãƒ³ãƒˆã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr "<emphasis>コンテナ管ç†ãƒ‡ãƒ¼ã‚¿ã‚½ãƒ¼ã‚¹</emphasis>：Hibernate㯠JNDIãŒæä¾›ã—ã€ã‚³ãƒ³ãƒ†ãƒŠãŒç®¡ç†ã™ã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’使用ã§ãã¾ã™ã€‚ 通常ã€JTAæº–æ‹ ã® <literal>TransactionManager</literal> 㨠<literal>ResourceManager</literal> ãŒãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ç®¡ç†(CMT)〠特ã«æ§˜ã€…ãªãƒ‡ãƒ¼ã‚¿ã‚½ãƒ¼ã‚¹ã«ã¾ãŸãŒã‚‹åˆ†æ•£ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’扱ã„ã¾ã™ã€‚ 当然プãƒã‚°ãƒ©ãƒ ã§ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’指定ã§ãã¾ã™(BMT)。 ã‚ã‚‹ã„ã¯ã€è¨˜è¿°ã—ãŸã‚³ãƒ¼ãƒ‰ã®ãƒãƒ¼ã‚¿ãƒ“リティをä¿ã¤ãŸã‚ã«ã€ オプションã®Hibernateã® <literal>Transaction</literal> APIを使ã„ãŸããªã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr "<emphasis>自動JNDIãƒã‚¤ãƒ³ãƒ‡ã‚£ãƒ³ã‚°</emphasis>：Hibernateã¯JNDIãŒç«‹ã¡ä¸ŠãŒã£ãŸå¾Œã« <literal>SessionFactory</literal> を生æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr "<emphasis>JTAセッションãƒã‚¤ãƒ³ãƒ‡ã‚£ãƒ³ã‚°</emphasis> ： Hibernate <literal>Session</literal> ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã¯JTAトランザクションã¨åŒã˜ã«ãªã‚Šã¾ã™ã€‚ å˜ç´”ã« <literal>SessionFactory</literal> ã‚’JNDIã‹ã‚‰lookupã—ã¦ã€ ç¾åœ¨ã® <literal>Session</literal> ã‚’å–å¾—ã—ã¾ã™ã€‚ JTAトランザクションãŒå®Œäº†ã—ãŸã¨ãã«ã€Hibernate㌠<literal>Session</literal> をフラッシュã—ã€ã‚¯ãƒãƒ¼ã‚ºã—ã¾ã™ã€‚ EJBデプãƒã‚¤ãƒ¡ãƒ³ãƒˆãƒ‡ã‚£ã‚¹ã‚¯ãƒªãƒ—ã‚¿ã®ä¸ã«ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’宣言ã—ã¾ã™ã€‚"
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr "<emphasis>JMXデプãƒã‚¤:</emphasis> ã‚‚ã—JMXãŒä½¿ç”¨å¯èƒ½ãªã‚¢ãƒ—リケーションサーãƒï¼ˆä¾‹ãˆã°JBOSS） ãŒã‚ã‚‹å ´åˆã€Hibernateã‚’MBeanã¨ã—ã¦ãƒ‡ãƒ—ãƒã‚¤ã™ã‚‹ã“ã¨ã‚’é¸ã¹ã¾ã™ã€‚ ã“れ㯠<literal>Configuration</literal> ã‹ã‚‰ <literal>SessionFactory</literal> ã‚’ 生æˆã™ã‚‹ã‚³ãƒ¼ãƒ‰ã‚’ç„¡ãã™ã“ã¨ãŒã§ãã¾ã™ã€‚ コンテナ㯠<literal>HibernateService</literal> ã‚’èµ·å‹•ã—〠サービスã®ä¾å˜ã‚’ç†æƒ³çš„ã«ç®¡ç†ã—ã¾ã™ï¼ˆãƒ‡ãƒ¼ã‚¿ã‚½ãƒ¼ã‚¹ã¯Hibernateã‚„ãã®ä»–ãŒèµ·å‹•ã™ã‚‹å‰ã« 使用ã§ãるよã†ã«ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“）。"
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr "環境ã«ä¾å˜ã—ã¾ã™ãŒã€ã‚‚ã—ã€ã‚¢ãƒ—リケーションサーãƒãŒ\"connection containment\"ã®ä¾‹å¤–をスãƒãƒ¼ã™ã‚‹ãªã‚‰ è¨å®šã®ã‚ªãƒ—ション <literal>hibernate.connection.aggressive_release</literal> ã‚’trueã«ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr "トランザクション戦略è¨å®š"
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr "Hibernate <literal>Session</literal> APIã¯ã€ã‚¢ãƒ¼ã‚テクãƒãƒ£å†…ã®ã‚·ã‚¹ãƒ†ãƒ ã®ç®¡è½„ã§ã‚ã‚‹ ã‚らゆるトランザクションã«ä¾å˜ã—ã¾ã›ã‚“。 ã‚‚ã—コãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールã®JDBCを直接使ã„ãŸã„å ´åˆã€JDBC APIã‹ã‚‰ トランザクションを呼ã¶ã“ã¨ãŒã§ãã¾ã™ã€‚ ã‚‚ã—ã€J2EEアプリケーションサーãƒã§å‹•ä½œã•ã›ã‚‹ãªã‚‰ã€Bean管ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã„〠必è¦ã«å¿œã˜ã¦ <literal>UserTransaction</literal> ã‚’JTA APIã‹ã‚‰å‘¼ã¶ã“ã¨ã«ãªã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr "2ã¤ï¼ˆãれ以上）ã®ç’°å¢ƒã§äº’æ›æ€§ã®ã‚るコードをç¶æŒã™ã‚‹ãŸã‚ã«ã€ã‚ªãƒ—ションã¨ã—ã¦æ ¹æœ¬çš„ãªã‚·ã‚¹ãƒ†ãƒ ã‚’ ラッピングã™ã‚‹Hibernate <literal>Transaction</literal> APIを推奨ã—ã¾ã™ã€‚ Hibernateè¨å®šãƒ—ãƒãƒ‘ティ㮠<literal>hibernate.transaction.factory_class</literal> ã‚’è¨å®šã™ã‚‹ã“ã¨ã§ ã‚る特定㮠<literal>Transaction</literal> クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’æŒã¤ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr "3ã¤ã®åŸºæœ¬çš„ãªï¼ˆæ—¢ã«ã‚る）é¸æŠžã‚’挙ã’ã¾ã™ï¼š"
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr "org.hibernate.transaction.JDBCTransactionFactory"
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr "データベース(JDBC)トランザクションã«å§”è²ã—ã¾ã™ï¼ˆãƒ‡ãƒ•ã‚©ãƒ«ãƒˆï¼‰"
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr "org.hibernate.transaction.JTATransactionFactory"
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr "ã‚‚ã—ã€ã“ã®ã‚³ãƒ³ãƒ†ã‚スト（例ãˆã°ã€EJBセッションBeanメソッド）ã§é€²è¡Œä¸ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒå˜åœ¨ã™ã‚‹ã€ã‚‚ã—ã㯠新ã—ã„トランザクションãŒé–‹å§‹ã•ã‚Œã¦ãŠã‚Šã€Bean管ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒä½¿ã‚ã‚Œã¦ã„ã‚‹å ´åˆã€ コンテナ管ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«å§”è²ã—ã¾ã™ã€‚"
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr "org.hibernate.transaction.CMTTransactionFactory"
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr "コンテナ管ç†JTAトランザクションã«å§”è²ã—ã¾ã™"
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr "自分自身ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³æˆ¦ç•¥ï¼ˆä¾‹ãˆã°ã€CORBAトランザクションサービス）を定義ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr "Hibernateã®ã„ãã¤ã‹ã®æ©Ÿèƒ½ï¼ˆä¾‹ãˆã°ã€äºŒæ¬¡ã‚ャッシュã€JTAã«ã‚ˆã‚‹ã‚³ãƒ³ãƒ†ã‚ストセッション ç‰ï¼‰ã¯ 管ç†ã•ã‚ŒãŸç’°å¢ƒã®ä¸ã®JTA <literal>TransactionManager</literal> ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã‚’è¦æ±‚ã—ã¾ã™ã€‚ J2EEãŒã²ã¨ã¤ã®ãƒ¡ã‚«ãƒ‹ã‚ºãƒ ã«è¦æ ¼åŒ–ã•ã‚Œã¦ã„ãªã„ã®ã§ã€ アプリケーションサーãƒã«ãŠã„ã¦ã€Hibernate㌠<literal>TransactionManager</literal> ã®ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹ ã‚’å–å¾—ã™ã‚‹æ–¹æ³•ã‚’明確ã«ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr "JTA トランザクションマãƒãƒ¼ã‚¸ãƒ£"
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr "Transaction Factory"
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr "Application Server"
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JBossTransactionManagerLookup"
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr "JBoss"
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr "Weblogic"
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr "WebSphere"
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr "WebSphere 6"
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr "org.hibernate.transaction.OrionTransactionManagerLookup"
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr "Orion"
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr "org.hibernate.transaction.ResinTransactionManagerLookup"
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr "Resin"
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JOTMTransactionManagerLookup"
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr "JOTM"
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JOnASTransactionManagerLookup"
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr "JOnAS"
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr "org.hibernate.transaction.JRun4TransactionManagerLookup"
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr "JRun4"
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr "org.hibernate.transaction.BESTransactionManagerLookup"
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr "Borland ES"
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr "<literal>SessionFactory</literal> ã®JNDIã¸ã®ç™»éŒ²"
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr "JNDIã«ç™»éŒ²ã—ãŸHibernate <literal>SessionFactory</literal> ã¯å˜ç´”㫠ファクトリをルックアップã—ã€æ–°ã—ã„ <literal>Session</literal> を作りã¾ã™ã€‚ ã“ã‚Œã¯JNDIã«ç™»éŒ²ã•ã‚ŒãŸ <literal>Datasource</literal> ã«ã¯é–¢é€£ã›ãšã€ ãŠäº’ã„ã«ã‚·ãƒ³ãƒ—ルã«ã“れらã®ç™»éŒ²ã‚’使ã†ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr "ã‚‚ã— <literal>SessionFactory</literal> ã‚’JNDIãƒãƒ¼ãƒ スペースã«ç™»éŒ²ã—ãŸã„å ´åˆã€ 特別ãªåå‰ï¼ˆä¾‹ãˆã°ã€ <literal>java:hibernate/SessionFactory</literal> ）を <literal>hibernate.session_factory_name</literal> プãƒãƒ‘ティã«ä½¿ã£ã¦ãã ã•ã„ ã‚‚ã—ã“ã®ãƒ—ãƒãƒ‘ティをçœç•¥ã—ãŸå ´åˆã€ <literal>SessionFactory</literal> 㯠JNDIã«ç™»éŒ²ã•ã‚Œã¾ã›ã‚“。（ã“ã‚Œã¯Tomcatã®ã‚ˆã†ãªãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå®Ÿè£…ã§JNDIãŒèªã¿ã‚ˆã‚Šå°‚用ã®ç’°å¢ƒã®å ´åˆç‰¹ã«ä¾¿åˆ©ã§ã™ã€‚）"
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr "<literal>SessionFactory</literal> ã‚’JNDIã«ç™»éŒ²ã™ã‚‹ã¨ãã€Hibernate㯠<literal>hibernate.jndi.url</literal> ã®å€¤ã‚’使用ã—ã€<literal>hibernate.jndi.class</literal> をイニシャルコンテã‚ストã¨ã—ã¦å…·ä½“化ã—ã¾ã™ã€‚ ã‚‚ã—何もè¨å®šã—ãªã„å ´åˆã¯ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã® <literal>InitialContext</literal> を使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr "<literal>cfg.buildSessionFactory()</literal> をコール後 Hibernateã¯è‡ªå‹•çš„ã« <literal>SessionFactory</literal> ã‚’JNDIã«é…ç½®ã—ã¾ã™ã€‚ <literal>HibernateService</literal> ã¨ä¸€ç·’ã«JMXデプãƒã‚¤ãƒ¡ãƒ³ãƒˆã‚’使ã‚ãªã„é™ã‚Šã€ ã“ã‚Œã¯ã“ã®å‘¼ã³å‡ºã—をアプリケーション内ã®ä½•ã‚‰ã‹ã®ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—コード（もã—ãã¯ãƒ¦ãƒ¼ãƒ†ã‚£ãƒªãƒ†ã‚£ã‚¯ãƒ©ã‚¹ï¼‰ ã«é…ç½®ã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚（後ã§è°è«–ã—ã¾ã™ï¼‰"
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr "ã‚‚ã—JNDI <literal>SessionFactory</literal> を使ã†å ´åˆã€EJBã‚„ä»–ã®ã‚¯ãƒ©ã‚¹ã¯ JNDIルックアップを使ã£ã¦ <literal>SessionFactory</literal> ã‚’å–å¾—ã—ã¾ã™ã€‚"
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr "管ç†ã•ã‚ŒãŸç’°å¢ƒã§ã¯ <literal>SessionFactory</literal> ã‚’JNDIã«ãƒã‚¤ãƒ³ãƒ‰ã—〠ãã†ã§ãªã‘れ㰠<literal>static</literal> シングルトンを使ã†ã“ã¨ã‚’推奨ã—ã¾ã™ã€‚ ã“ã†ã„ã£ãŸè©³ç´°ã‹ã‚‰ã‚¢ãƒ—リケーションコードをä¿è·ã™ã‚‹ãŸã‚ã«ã€ <literal>HibernateUtil.getSessionFactory()</literal> ã®ã‚ˆã†ãªãƒ˜ãƒ«ãƒ‘ークラスã®ä¸ã«ã€ <literal>SessionFactory</literal> をルックアップã™ã‚‹ã‚³ãƒ¼ãƒ‰ã‚’éš ã™ã“ã¨ã‚’推奨ã—ã¾ã™ã€‚ ã“ã®ã‚ˆã†ãªãƒ˜ãƒ«ãƒ‘ークラスã¯Hibernateを開始ã™ã‚‹ä¾¿åˆ©ãªæ‰‹æ®µã§ã‚‚ã‚ã‚Šã¾ã™ã€‚ —ï¼‘ç« ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr "JTAã«ã‚ˆã‚‹ç¾åœ¨ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚³ãƒ³ãƒ†ã‚ストマãƒãƒ¼ã‚¸ãƒ¡ãƒ³ãƒˆ"
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr "ã‚‚ã£ã¨ã‚‚ç°¡å˜ã« <literal>Session</literal> ã¨ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’扱ã†æ–¹æ³•ã¯ã€ HibernateãŒè‡ªå‹•çš„ã«ã€Œç¾åœ¨ã®ã€ <literal>Session</literal> を管ç†ã™ã‚‹ã“ã¨ã§ã™ã€‚ <xref linkend=\"architecture-current-session\"/>カレントセッション ã®èª¬æ˜Žã‚’å‚ç…§ã—ã¦ãã ã•ã„。 ã‚‚ã— <literal>「JTAã€</literal> セッションコンテã‚ストを使ã£ãŸä¸Šã§ã€ ç¾åœ¨ã®JTAトランザクションã¨Hibernate <literal>Session</literal> ãŒé–¢é€£ã—ã¦ã„ãªã„å ´åˆã¯ã€ 最åˆã« <literal>sessionFactory.getCurrentSession()</literal> をコールã—〠JTAトランザクションã¨ã®é–¢é€£ä»˜ã‘ã‚’è¡Œã£ã¦ãã ã•ã„。 <literal>「JTAã€</literal> コンテã‚スト㮠<literal>getCurrentSession()</literal> ã‚’ 通ã˜ã¦å–å¾—ã—㟠<literal>Session</literal> ã¯ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒå®Œäº†ã™ã‚‹å‰ã« 自動的ã«ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã—ã€å®Œäº†ã—ãŸå¾Œã«ã¯è‡ªå‹•çš„ã«ã‚¯ãƒãƒ¼ã‚ºã—ã¾ã™ã€‚ ã¾ãŸã€å„ステーã!
ƒˆãƒ¡ãƒ³ãƒˆå¾Œã«JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’ç©æ¥µçš„ã«ãƒªãƒªãƒ¼ã‚¹ã—ã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚ŠJTAトランザクションã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã§ <literal>Session</literal> を管ç†ã™ã‚‹ã“ã¨ãŒã§ã〠ユーザーã®ã‚³ãƒ¼ãƒ‰ã‹ã‚‰ãã®ã‚ˆã†ãªç®¡ç†ã‚’ã™ã‚‹ã‚³ãƒ¼ãƒ‰ã‚’排除ã§ãã¾ã™ã€‚ <literal>UserTransaction</literal> を通ã˜ã¦JTAをプãƒã‚°ãƒ©ãƒ ã§ç®¡ç†ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã¾ãŸã¯ã€ï¼ˆãƒãƒ¼ã‚¿ãƒ–ルãªã‚³ãƒ¼ãƒ‰ã§ã‚ã‚Œã°ï¼‰Hibernate <literal>Transaction</literal> APIã‚’ トランザクション境界ã¨ã—ã¦ä½¿ã†ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ EJBコンテナを使ã†ã¨ãã¯ã€CMTã«ã‚ˆã‚‹å®£è¨€çš„トランザクション境界ãŒå¥½ã¾ã—ã„ã§ã™ã€‚"
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr "JMXデプãƒã‚¤ãƒ¡ãƒ³ãƒˆ"
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr "<literal>SessionFactory</literal> ã‚’JNDIã‹ã‚‰å–å¾—ã™ã‚‹ãŸã‚ã«ã¯ <literal>cfg.buildSessionFactory()</literal> 行をã©ã“ã‹ã§å®Ÿè¡Œã—ã¦ã„ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã‚ãªãŸã¯ã“れをã€<literal>static</literal> åˆæœŸåŒ–ブãƒãƒƒã‚¯å†…（ <literal>HibernateUtil</literal> ã®ã‚ˆã†ãªï¼‰ã‹ <emphasis>managed service</emphasis> ã¨ã—ã¦Hibernateをデプãƒã‚¤ã™ã‚‹ã‹ã€ã©ã¡ã‚‰ã‹ã§å®Ÿè¡Œã§ãã¾ã™ã€‚"
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr "JBOSSã®ã‚ˆã†ãªJMXã®æ©Ÿèƒ½ã§ã‚¢ãƒ—リケーションサーãƒã«ãƒ‡ãƒ—ãƒã‚¤ã™ã‚‹ãŸã‚ã« <literal>org.hibernate.jmx.HibernateService</literal> を使ã£ã¦ã€é…ç½®ã—ã¾ã™ã€‚ 実際ã®ãƒ‡ãƒ—ãƒã‚¤ãƒ¡ãƒ³ãƒˆã¨è¨å®šã¯ãƒ™ãƒ³ãƒ€ãƒ¼ç‰¹æœ‰ã§ã™ã€‚ ã“ã“ã§ä¾‹ã¨ã—ã¦JBOSS 4.0.x用㮠<literal>jboss-service.xml</literal> を示ã—ã¾ã™ã€‚"
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr "ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã¯ <literal>META-INF</literal> ディレクトリã«é…ç½®ã•ã‚Œã€ JARファイルを拡張ã—㟠<literal>.sar</literal> (service archive)ã§ãƒ‘ッケージ化ã•ã‚Œã¾ã™ã€‚ åŒæ§˜ã«Hibernateパッケージも必è¦ã§ã™ã€‚ã¾ãŸã€Hibernateã¯ã‚µãƒ¼ãƒ‰ãƒ‘ーティã®ãƒ©ã‚¤ãƒ–ラリもè¦æ±‚ã—ã¾ã™ã€‚ コンパイルã—ãŸæ°¸ç¶šåŒ–クラスã¨ãã®ãƒžãƒƒãƒ”ングファイルもåŒæ§˜ã«ã‚¢ãƒ¼ã‚«ã‚¤ãƒ–（.sarファイル）ã«å…¥ã‚Œã¾ã™ã€‚ エンタープライズbean（通常ã¯ã‚»ãƒƒã‚·ãƒ§ãƒ³bean）ã¯è‡ªèº«ã®JARファイルをä¿æŒã—ã¾ã™ãŒã€ 1回ã§ï¼ˆãƒ›ãƒƒãƒˆï¼‰ãƒ‡ãƒ—ãƒã‚¤å¯èƒ½ãªãƒ¦ãƒ‹ãƒƒãƒˆã®ãŸã‚ã«ãƒ¡ã‚¤ãƒ³ã‚µãƒ¼ãƒ“スアーカイブã¨ã—ã¦ã“ã®EJB JARファイルをインクルードã™ã‚‹ ã“ã¨ãŒã§ãã¾ã™ã€‚JBossアプリケーションサーãƒã®ãƒ‰ã‚ュメントã«JXMサービス㨠EJBデプãƒã‚¤ãƒ¡ãƒ³ãƒˆã®ã‚ˆã‚Šå¤šãã®æƒ…å ±ãŒã‚ã‚Šã¾ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,457 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr "インターセプタã¨ã‚¤ãƒ™ãƒ³ãƒˆ"
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr "アプリケーションãŒHibernateã®å†…部ã§ç™ºç”Ÿã™ã‚‹ã‚¤ãƒ™ãƒ³ãƒˆã«å¯¾å¿œã§ãã‚‹ã¨å½¹ã«ç«‹ã¤ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ ã‚る種ã®ä¸€èˆ¬çš„ãªæ©Ÿèƒ½ã‚’実装ã§ãるよã†ã«ãªã‚Šã€ ã¾ãŸHibernateã®æ©Ÿèƒ½ã‚’æ‹¡å¼µã™ã‚‹ã“ã¨ã‚‚ã§ãるよã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr "インターセプタ"
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr "<literal>Interceptor</literal> インターフェイスを使ã£ã¦ã€ セッションã‹ã‚‰ã‚¢ãƒ—リケーションã¸ã‚³ãƒ¼ãƒ«ãƒãƒƒã‚¯ã‚’ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚Šæ°¸ç¶šã‚ªãƒ–ジェクトã®ä¿å˜ã€æ›´æ–°ã€å‰Šé™¤ã€èªã¿è¾¼ã¿ã®å‰ã«ã€ アプリケーションãŒãƒ—ãƒãƒ‘ティを検査ã—ãŸã‚Šæ“作ã—ãŸã‚Šã§ãるよã†ã«ãªã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ç›£æŸ»æƒ…å ±ã®è¿½è·¡ã«åˆ©ç”¨ã§ãã¾ã™ã€‚ 下ã®ä¾‹ã§ <literal>Interceptor</literal> 㯠<literal>Auditable</literal> ãŒä½œæˆã•ã‚Œã‚‹ã¨è‡ªå‹•çš„ã« <literal>createTimestamp</literal> ã‚’è¨å®šã—〠<literal>Auditable</literal> ãŒæ›´æ–°ã•ã‚Œã‚‹ã¨è‡ªå‹•çš„ã« <literal>lastUpdateTimestamp</literal> プãƒãƒ‘ティを更新ã—ã¾ã™ã€‚"
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr "<literal>Interceptor</literal> を直接実装ã—ãŸã‚Šã€ （ã•ã‚‰ã«ã‚ˆã„ã®ã¯ï¼‰<literal>EmptyInterceptor</literal> ã‚’æ‹¡å¼µã—ãŸã‚Šã§ãã¾ã™ã€‚"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package org.hibernate.test;
+\n"
+ "
+\n"
+ "import java.io.Serializable;
+\n"
+ "import java.util.Date;
+\n"
+ "import java.util.Iterator;
+\n"
+ "
+\n"
+ "import org.hibernate.EmptyInterceptor;
+\n"
+ "import org.hibernate.Transaction;
+\n"
+ "import org.hibernate.type.Type;
+\n"
+ "
+\n"
+ "public class AuditInterceptor extends EmptyInterceptor {
+\n"
+ "
+\n"
+ " private int updates;
+\n"
+ " private int creates;
+\n"
+ " private int loads;
+\n"
+ "
+\n"
+ " public void onDelete(Object entity,
+\n"
+ " Serializable id,
+\n"
+ " Object[] state,
+\n"
+ " String[] propertyNames,
+\n"
+ " Type[] types) {
+\n"
+ " // do nothing
+\n"
+ " }
+\n"
+ "
+\n"
+ " public boolean onFlushDirty(Object entity,
+\n"
+ " Serializable id,
+\n"
+ " Object[] currentState,
+\n"
+ " Object[] previousState,
+\n"
+ " String[] propertyNames,
+\n"
+ " Type[] types) {
+\n"
+ "
+\n"
+ " if ( entity instanceof Auditable ) {
+\n"
+ " updates++;
+\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {
+\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {
+\n"
+ " currentState[i] = new Date();
+\n"
+ " return true;
+\n"
+ " }
+\n"
+ " }
+\n"
+ " }
+\n"
+ " return false;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public boolean onLoad(Object entity,
+\n"
+ " Serializable id,
+\n"
+ " Object[] state,
+\n"
+ " String[] propertyNames,
+\n"
+ " Type[] types) {
+\n"
+ " if ( entity instanceof Auditable ) {
+\n"
+ " loads++;
+\n"
+ " }
+\n"
+ " return false;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public boolean onSave(Object entity,
+\n"
+ " Serializable id,
+\n"
+ " Object[] state,
+\n"
+ " String[] propertyNames,
+\n"
+ " Type[] types) {
+\n"
+ "
+\n"
+ " if ( entity instanceof Auditable ) {
+\n"
+ " creates++;
+\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {
+\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {
+\n"
+ " state[i] = new Date();
+\n"
+ " return true;
+\n"
+ " }
+\n"
+ " }
+\n"
+ " }
+\n"
+ " return false;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void afterTransactionCompletion(Transaction tx) {
+\n"
+ " if ( tx.wasCommitted() ) {
+\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);
+\n"
+ " }
+\n"
+ " updates=0;
+\n"
+ " creates=0;
+\n"
+ " loads=0;
+\n"
+ " }
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr "インターセプタã«ã¯äºŒç¨®é¡žã‚ã‚Šã¾ã™ï¼š <literal>Session</literal> スコープã®ã‚‚ã®ã¨ <literal>SessionFactory</literal> スコープã®ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr "<literal>Session</literal> スコープã®ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—ã‚¿ã¯ã€ セッションをオープンã™ã‚‹ã¨ãã«æŒ‡å®šã—ã¾ã™ã€‚ <literal>Interceptor</literal> を引数ã«å–ã‚‹SessionFactory.openSession() ã®ã‚ªãƒ¼ãƒãƒ¼ãƒãƒ¼ãƒ‰ãƒ¡ã‚½ãƒƒãƒ‰ã®ä¸€ã¤ã‚’使ã„ã¾ã™ã€‚"
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr "<literal>SessionFactory</literal> スコープã®ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—タ㯠<literal>Configuration</literal> オブジェクトを使ã£ã¦ç™»éŒ²ã—ã¾ã™ã€‚ ã“れ㯠<literal>SessionFactory</literal> ã®æ§‹ç¯‰ã‚ˆã‚Šã‚‚優先ã•ã‚Œã¾ã™ã€‚ ã“ã®å ´åˆã€æä¾›ã•ã‚Œã‚‹ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—タ㯠<literal>SessionFactory</literal> ã‹ã‚‰ã‚ªãƒ¼ãƒ—ンã•ã‚ŒãŸã™ã¹ã¦ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«é©ç”¨ã•ã‚Œã¾ã™ã€‚ ã“ã‚Œã¯ä½¿ç”¨ã™ã‚‹ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—タを明示的ã«æŒ‡å®šã—ã¦ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚’オープンã—ãªã„é™ã‚Šã€ãã†ãªã‚Šã¾ã™ã€‚ <literal>SessionFactory</literal> スコープã®ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—ã‚¿ã¯ã‚¹ãƒ¬ãƒƒãƒ‰ã‚»ãƒ¼ãƒ•ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 複数ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ãŒï¼ˆæ½œåœ¨çš„ã«ï¼‰ã“ã®ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—ã‚¿ã‚’åŒæ™‚並行ã§ä½¿ç”¨ã™ã‚‹ã“ã¨ã«ãªã‚‹ãŸã‚〠セッション固有ã®çŠ¶æ…‹ã‚’æ ¼ç´ã—ãªã„よã†ã«æ°—ã‚’ã¤ã‘ã¦ãã ã•ã„。"
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+
+#: index.docbook:61
+msgid "Event system"
+msgstr "イベントシステム"
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr "永続化層ã§ç‰¹å®šã®ã‚¤ãƒ™ãƒ³ãƒˆã«å¯¾å¿œã—ãªã‘ã‚Œã°ãªã‚‰ãªã„å ´åˆã€ Hibernate3ã® <emphasis>イベント</emphasis> アーã‚テクãƒãƒ£ã‚’使ã†ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ イベントシステムã¯ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—ã‚¿ã¨ä¸€ç·’ã«ä½¿ã†ã‹ã€ã¾ãŸã¯ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—ã‚¿ã®ä»£ã‚ã‚Šã¨ã—ã¦ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr "本質的㫠<literal>Session</literal> インターフェイスã®ã™ã¹ã¦ã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ã€ 1個ã®ã‚¤ãƒ™ãƒ³ãƒˆã¨ç›¸äº’ã«é–¢é€£ã—ã¾ã™ã€‚ 例ãˆã° <literal>LoadEvent</literal>ã€<literal>FlushEvent</literal> ãªã©ãŒã‚ã‚Šã¾ã™ （定義済ã¿ã®ã‚¤ãƒ™ãƒ³ãƒˆåž‹ã®ä¸€è¦§ã«ã¤ã„ã¦ã¯ã€XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã®DTDã‚„ <literal>org.hibernate.event</literal> パッケージを調ã¹ã¦ãã ã•ã„）。 リクエストãŒã“れらã®ãƒ¡ã‚½ãƒƒãƒ‰ã®1ã¤ã‹ã‚‰ä½œã‚‰ã‚Œã‚‹ã¨ã〠Hibernateã® <literal>Session</literal> ã¯é©åˆ‡ãªã‚¤ãƒ™ãƒ³ãƒˆã‚’生æˆã—〠ãã®ã‚¤ãƒ™ãƒ³ãƒˆåž‹ã«è¨å®šã•ã‚ŒãŸã‚¤ãƒ™ãƒ³ãƒˆãƒªã‚¹ãƒŠã«æ¸¡ã—ã¾ã™ã€‚ ã™ã°ã‚‰ã—ã„ã“ã¨ã«ã€ã“れらã®ãƒªã‚¹ãƒŠã¯ãã®ãƒ¡ã‚½ãƒƒãƒ‰ã¨åŒã˜å‡¦ç†ã‚’実装ã—ã¾ã™ã€‚ ã¨ã¯ã„ãˆã€ãƒªã‚¹ãƒŠã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã®ä¸€ã¤ã‚’自由ã«ã‚«ã‚¹ã‚¿ãƒ 実装ã§ãã¾ã™ （ã¤ã¾ã‚Šã€<literal>LoadEvent</literal> ã¯ç™»éŒ²ã•ã‚ŒãŸ <literal>LoadEventListener</literal> インターフェイ!
スã®å®Ÿè£…ã«ã‚ˆã‚Šå‡¦ç†ã•ã‚Œã¾ã™ï¼‰ã€‚ ãã®å ´åˆã€ãã®å®Ÿè£…ã«ã¯ <literal>Session</literal> ã‹ã‚‰ä½œã‚‰ã‚ŒãŸã©ã®ã‚ˆã†ãª <literal>load()</literal> リクエストをも処ç†ã™ã‚‹è²¬ä»»ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr "リスナã¯äº‹å®Ÿä¸Šã‚·ãƒ³ã‚°ãƒ«ãƒˆãƒ³ã§ã‚ã‚‹ã¨è¦‹ãªã›ã¾ã™ã€‚ ã¤ã¾ã‚Šãƒªã‚¹ãƒŠã¯ãƒªã‚¯ã‚¨ã‚¹ãƒˆé–“ã§å…±æœ‰ã•ã‚Œã‚‹ãŸã‚〠インスタンス変数ã¨ã—ã¦çŠ¶æ…‹ã‚’ä¿æŒã™ã‚‹ã¹ãã§ã¯ãªã„ã¨ã„ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr "カスタムリスナã¯å‡¦ç†ã—ãŸã„イベントã«ã¤ã„ã¦é©åˆ‡ãªã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã™ã‚‹ã¹ãã§ã™ã€‚ 便利ãªåŸºåº•ã‚¯ãƒ©ã‚¹ã®ã†ã¡ã®ä¸€ã¤ã‚’継承ã—ã¦ã‚‚よã„ã§ã™ （ã¾ãŸã¯HibernateãŒãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ä½¿ç”¨ã™ã‚‹ã‚¤ãƒ™ãƒ³ãƒˆãƒªã‚¹ãƒŠã‚’継承ã—ã¦ã‚‚よã„ã§ã™ã€‚ ã™ã°ã‚‰ã—ã„ã“ã¨ã«ã€ã“ã®ç›®çš„ã®ãŸã‚ã«éžfinalã¨ã—ã¦å®£è¨€ã•ã‚Œã¦ã„ã¾ã™ï¼‰ã€‚ カスタムリスナ㯠<literal>Configuration</literal> オブジェクトを使ã£ã¦ãƒ—ãƒã‚°ãƒ©ãƒ ã‹ã‚‰ç™»éŒ²ã™ã‚‹ã‹ã€ Hibernateã®XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã§æŒ‡å®šã§ãã¾ã™ （プãƒãƒ‘ティファイルã§å®£è¨€çš„ã«è¨å®šã™ã‚‹æ–¹æ³•ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“）。 カスタムãƒãƒ¼ãƒ‰ã‚¤ãƒ™ãƒ³ãƒˆãƒªã‚¹ãƒŠã®ä¾‹ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {
+\n"
+ " // this is the single method defined by the LoadEventListener interface
+\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)
+\n"
+ " throws HibernateException {
+\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {
+\n"
+ " throw MySecurityException(\"Unauthorized access\");
+\n"
+ " }
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr "デフォルトリスナ以外ã®ãƒªã‚¹ãƒŠã‚’使ã†ã«ã¯ã€Hibernateã¸ã®è¨å®šã‚‚å¿…è¦ã§ã™ï¼š"
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-configuration>
+\n"
+ " <session-factory>
+\n"
+ " ...
+\n"
+ " <event type=\"load\">
+\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>
+\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>
+\n"
+ " </event>
+\n"
+ " </session-factory>
+\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr "ã¾ãŸãã®ä»–ã«ã€ãƒ—ãƒã‚°ãƒ©ãƒ ã§ç™»éŒ²ã™ã‚‹æ–¹æ³•ã‚‚ã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration();
+\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };
+\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr "リスナを宣言的ã«ç™»éŒ²ã™ã‚‹ã¨ã€ãã®ãƒªã‚¹ãƒŠã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’共有ã§ãã¾ã›ã‚“。 複数㮠<literal><listener/></literal> è¦ç´ ã§åŒã˜ã‚¯ãƒ©ã‚¹åãŒä½¿ã‚れるã¨ã€ ãã‚Œãžã‚Œã®å‚ç…§ã¯ãã®ã‚¯ãƒ©ã‚¹ã®åˆ¥ã€…ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’指ã™ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ リスナ型ã®é–“ã§ãƒªã‚¹ãƒŠã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’共有ã™ã‚‹å¿…è¦ãŒã‚ã‚Œã°ã€ プãƒã‚°ãƒ©ãƒ ã§ç™»éŒ²ã™ã‚‹æ–¹æ³•ã‚’採らãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr "ãªãœã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã—ã¦ã€ç‰¹åŒ–ã—ãŸåž‹ã‚’è¨å®šæ™‚ã«æŒ‡å®šã™ã‚‹ã®ã§ã—ょã†ã‹ï¼Ÿ リスナã®å®Ÿè£…クラスã«ã€è¤‡æ•°ã®ã‚¤ãƒ™ãƒ³ãƒˆãƒªã‚¹ãƒŠã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã§ãã‚‹ã‹ã‚‰ã§ã™ã€‚ 登録時ã«è¿½åŠ ã§åž‹ã‚’指定ã™ã‚‹ã“ã¨ã§ã€ã‚«ã‚¹ã‚¿ãƒ リスナã®on/offã‚’è¨å®šæ™‚ã«ç°¡å˜ã«åˆ‡ã‚Šæ›¿ãˆã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr "Hibernateã®å®£è¨€çš„ãªã‚»ã‚ュリティ"
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr "一般的ã«Hibernateアプリケーションã®å®£è¨€çš„ãªã‚»ã‚ュリティã¯ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ãƒ•ã‚¡ã‚µãƒ¼ãƒ‰å±¤ã§ç®¡ç†ã—ã¾ã™ã€‚ ç¾åœ¨ã€Hiberenate3ã¯JACCã§è¨±å¯ã—ã‹ã¤ã€JAASã§èªè¨¼ã—ãŸã‚¢ã‚¯ã‚·ãƒ§ãƒ³ã‚’許ã—ã¦ã„ã¾ã™ã€‚ ã“ã‚Œã¯ã‚¤ãƒ™ãƒ³ãƒˆã‚¢ãƒ¼ã‚テクãƒãƒ£ã®æœ€ä¸Šä½ã«çµ„ã¿è¾¼ã¾ã‚Œã¦ã„るオプションã®æ©Ÿèƒ½ã§ã™ã€‚"
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr "ã¾ãšæœ€åˆã«ã€é©åˆ‡ãªã‚¤ãƒ™ãƒ³ãƒˆãƒªã‚¹ãƒŠã‚’è¨å®šã—ã¦JAASèªè¨¼ã‚’使ãˆã‚‹ã‚ˆã†ã«ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>
+\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>
+\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>
+\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr "特定ã®ã‚¤ãƒ™ãƒ³ãƒˆåž‹ã«å¯¾ã—ã¦ã¡ã‚‡ã†ã©ä¸€ã¤ã®ãƒªã‚¹ãƒŠãŒã‚ã‚‹ã¨ã〠<literal><listener type=\"...\" class=\"...\"/></literal> 㯠<literal><event type=\"...\"><listener class=\"...\"/></event></literal> ã®ç°¡ç•¥å½¢ã«éŽãŽãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr "次ã«ã€åŒã˜ã <literal>hibernate.cfg.xml</literal> ã§ãƒãƒ¼ãƒ«ã«ãƒ‘ーミッションを与ãˆã¦ãã ã•ã„："
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>
+\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr "ã“ã®ãƒãƒ¼ãƒ«åã¯ä½¿ç”¨ã™ã‚‹JACCプãƒãƒã‚¤ãƒ€ã«ç†è§£ã•ã‚Œã‚‹ãƒãƒ¼ãƒ«ã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1660 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr "例：ã„ã‚ã„ã‚ãªãƒžãƒƒãƒ”ング"
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr "ã“ã®ç« ã§ã¯ã€ã‚ˆã‚Šè¤‡é›‘ãªé–¢é€£ã®ãƒžãƒƒãƒ”ングをã„ãã¤ã‹ç´¹ä»‹ã—ã¾ã™ã€‚"
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr "雇用者/従æ¥å“¡"
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr "<literal>Employer</literal> 㨠<literal>Employee</literal> ã®é–¢ä¿‚を表ã™ä»¥ä¸‹ã®ãƒ¢ãƒ‡ãƒ«ã¯ã€ 関連ã®è¡¨ç¾ã«å®Ÿéš›ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ï¼ˆ <literal>Employment</literal> ） を使ã„ã¾ã™ã€‚ ãªãœãªã‚‰ã€åŒã˜2ã¤ã®ãƒ‘ーティã«è¤‡æ•°ã®æœŸé–“雇用ã•ã‚Œã‚‹ã¨ã„ã†ã“ã¨ãŒã‚ã‚Šãˆã‚‹ã‹ã‚‰ã§ã™ã€‚ ãŠé‡‘ã®å€¤ã¨å¾“æ¥å“¡ã®åå‰ã‚’モデル化ã™ã‚‹ãŸã‚ã«ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚’使ã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr "マッピングドã‚ュメントã®ä¸€ä¾‹ã§ã™ï¼š"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"Employer\" table=\"employers\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"sequence\">
+\n"
+ " <param name=\"sequence\">employer_id_seq</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " <property name=\"name\"/>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Employment\" table=\"employment_periods\">
+\n"
+ "
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"sequence\">
+\n"
+ " <param name=\"sequence\">employment_id_seq</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " <property name=\"startDate\" column=\"start_date\"/>
+\n"
+ " <property name=\"endDate\" column=\"end_date\"/>
+\n"
+ "
+\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">
+\n"
+ " <property name=\"amount\">
+\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>
+\n"
+ " </property>
+\n"
+ " <property name=\"currency\" length=\"12\"/>
+\n"
+ " </component>
+\n"
+ "
+\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>
+\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Employee\" table=\"employees\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"sequence\">
+\n"
+ " <param name=\"sequence\">employee_id_seq</param>
+\n"
+ " </generator>
+\n"
+ " </id>
+\n"
+ " <property name=\"taxfileNumber\"/>
+\n"
+ " <component name=\"name\" class=\"Name\">
+\n"
+ " <property name=\"firstName\"/>
+\n"
+ " <property name=\"initial\"/>
+\n"
+ " <property name=\"lastName\"/>
+\n"
+ " </component>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr "<literal>SchemaExport</literal> ã§ç”Ÿæˆã—ãŸãƒ†ãƒ¼ãƒ–ルスã‚ーマã§ã™ã€‚"
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+ "<![CDATA[create table employers (
+\n"
+ " id BIGINT not null,
+\n"
+ " name VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table employment_periods (
+\n"
+ " id BIGINT not null,
+\n"
+ " hourly_rate NUMERIC(12, 2),
+\n"
+ " currency VARCHAR(12),
+\n"
+ " employee_id BIGINT not null,
+\n"
+ " employer_id BIGINT not null,
+\n"
+ " end_date TIMESTAMP,
+\n"
+ " start_date TIMESTAMP,
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table employees (
+\n"
+ " id BIGINT not null,
+\n"
+ " firstName VARCHAR(255),
+\n"
+ " initial CHAR(1),
+\n"
+ " lastName VARCHAR(255),
+\n"
+ " taxfileNumber VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "alter table employment_periods
+\n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers
+\n"
+ "alter table employment_periods
+\n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees
+\n"
+ "create sequence employee_id_seq
+\n"
+ "create sequence employment_id_seq
+\n"
+ "create sequence employer_id_seq]]>"
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr "作者/作å“"
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr "<literal>Work</literal> , <literal>Author</literal> ãã—㦠<literal>Person</literal> ã®é–¢ä¿‚を表ã™ä»¥ä¸‹ã®ãƒ¢ãƒ‡ãƒ«ã‚’考ãˆã¦ã¿ã¦ãã ã•ã„。 <literal>Work</literal> 㨠<literal>Author</literal> ã®é–¢ä¿‚を多対多関連ã§è¡¨ã—ã¦ã„ã¾ã™ã€‚ <literal>Author</literal> 㨠<literal>Person</literal> ã®é–¢ä¿‚ã¯ä¸€å¯¾ä¸€é–¢é€£ã¨ã—ã¦è¡¨ã—ã¦ã„ã¾ã™ã€‚ ä»–ã«ã¯ <literal>Author</literal> ㌠<literal>Person</literal> ã‚’æ‹¡å¼µã™ã‚‹ã¨ã„ã†æ–¹æ³•ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr "以下ã®ãƒžãƒƒãƒ”ングドã‚ュメントã¯ã“ã®ã‚ˆã†ãªé–¢ä¿‚ã‚’æ£ç¢ºã«è¡¨ç¾ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">
+\n"
+ "
+\n"
+ " <id name=\"id\" column=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <discriminator column=\"type\" type=\"character\"/>
+\n"
+ "
+\n"
+ " <property name=\"title\"/>
+\n"
+ " <set name=\"authors\" table=\"author_work\">
+\n"
+ " <key column name=\"work_id\"/>
+\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>
+\n"
+ " </set>
+\n"
+ "
+\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">
+\n"
+ " <property name=\"text\"/>
+\n"
+ " </subclass>
+\n"
+ "
+\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">
+\n"
+ " <property name=\"tempo\"/>
+\n"
+ " <property name=\"genre\"/>
+\n"
+ " </subclass>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Author\" table=\"authors\">
+\n"
+ "
+\n"
+ " <id name=\"id\" column=\"id\">
+\n"
+ " <!-- The Author must have the same identifier as the Person -->
+\n"
+ " <generator class=\"assigned\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"alias\"/>
+\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>
+\n"
+ "
+\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">
+\n"
+ " <key column=\"author_id\"/>
+\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>
+\n"
+ " </set>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Person\" table=\"persons\">
+\n"
+ " <id name=\"id\" column=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"name\"/>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr "ã“ã®ãƒžãƒƒãƒ”ングã«ã¯4ã¤ã®ãƒ†ãƒ¼ãƒ–ルãŒã‚ã‚Šã¾ã™ã€‚ <literal>works</literal> , <literal>authors</literal> , <literal>persons</literal> ã¯ãã‚Œãžã‚Œã€ä»•äº‹ã€ä½œè€…ã€äººã®ãƒ‡ãƒ¼ã‚¿ã‚’ä¿æŒã—ã¾ã™ã€‚ <literal>author_work</literal> ã¯ä½œè€…ã¨ä½œå“をリンクã™ã‚‹é–¢é€£ãƒ†ãƒ¼ãƒ–ルã§ã™ã€‚ 以下㯠<literal>SchemaExport</literal> ã§ç”Ÿæˆã—ãŸãƒ†ãƒ¼ãƒ–ルスã‚ーマã§ã™ã€‚"
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+ "<![CDATA[create table works (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " tempo FLOAT,
+\n"
+ " genre VARCHAR(255),
+\n"
+ " text INTEGER,
+\n"
+ " title VARCHAR(255),
+\n"
+ " type CHAR(1) not null,
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table author_work (
+\n"
+ " author_id BIGINT not null,
+\n"
+ " work_id BIGINT not null,
+\n"
+ " primary key (work_id, author_id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table authors (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " alias VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table persons (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " name VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "alter table authors
+\n"
+ " add constraint authorsFK0 foreign key (id) references persons
+\n"
+ "alter table author_work
+\n"
+ " add constraint author_workFK0 foreign key (author_id) references authors
+\n"
+ "alter table author_work
+\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr "顧客/注文/製å“"
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr "ã•ã¦ã€ <literal>Customer</literal> , <literal>Order</literal> , <literal>LineItem</literal> <literal>Product</literal> ã®é–¢ä¿‚を表ã™ãƒ¢ãƒ‡ãƒ«ã‚’考ãˆã¦ã¿ã¾ã—ょã†ã€‚ <literal>Customer</literal> 㨠<literal>Order</literal> ã¯ä¸€å¯¾å¤šã®é–¢é€£ã§ã™ãŒã€ <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal> ã¯ã©ã®ã‚ˆã†ã«è¡¨ç¾ã™ã‚‹ã¹ãã§ã—ょã†ã‹ï¼Ÿ <literal>LineItem</literal> ã‚’ã€<literal>Order</literal> 㨠<literal>Product</literal> ã®å¤šå¯¾å¤šé–¢é€£ã‚’表ç¾ã™ã‚‹é–¢é€£ã‚¯ãƒ©ã‚¹ã¨ã—ã¦ãƒžãƒƒãƒ”ングã—ã¾ã—ãŸã€‚ Hibernateã§ã¯ã“れをコンãƒã‚¸ãƒƒãƒˆè¦ç´ ã¨å‘¼ã³ã¾ã™ã€‚"
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr "マッピングドã‚ュメント："
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"Customer\" table=\"customers\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"name\"/>
+\n"
+ " <set name=\"orders\" inverse=\"true\">
+\n"
+ " <key column=\"customer_id\"/>
+\n"
+ " <one-to-many class=\"Order\"/>
+\n"
+ " </set>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Order\" table=\"orders\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"date\"/>
+\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>
+\n"
+ " <list name=\"lineItems\" table=\"line_items\">
+\n"
+ " <key column=\"order_id\"/>
+\n"
+ " <list-index column=\"line_number\"/>
+\n"
+ " <composite-element class=\"LineItem\">
+\n"
+ " <property name=\"quantity\"/>
+\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>
+\n"
+ " </composite-element>
+\n"
+ " </list>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ " <class name=\"Product\" table=\"products\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"serialNumber\"/>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr "<literal>customers</literal> , <literal>orders</literal> , <literal>line_items</literal> , <literal>products</literal> ã¯ãã‚Œãžã‚Œã€é¡§å®¢ã€æ³¨æ–‡ã€æ³¨æ–‡æ˜Žç´°ã€è£½å“ã®ãƒ‡ãƒ¼ã‚¿ã‚’ä¿æŒã—ã¾ã™ã€‚ <literal>line_items</literal> ã¯æ³¨æ–‡ã¨è£½å“をリンクã™ã‚‹é–¢é€£ãƒ†ãƒ¼ãƒ–ルã¨ã—ã¦ã‚‚åƒãã¾ã™ã€‚"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+ "<![CDATA[create table customers (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " name VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table orders (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " customer_id BIGINT,
+\n"
+ " date TIMESTAMP,
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table line_items (
+\n"
+ " line_number INTEGER not null,
+\n"
+ " order_id BIGINT not null,
+\n"
+ " product_id BIGINT,
+\n"
+ " quantity INTEGER,
+\n"
+ " primary key (order_id, line_number)
+\n"
+ ")
+\n"
+ "
+\n"
+ "create table products (
+\n"
+ " id BIGINT not null generated by default as identity,
+\n"
+ " serialNumber VARCHAR(255),
+\n"
+ " primary key (id)
+\n"
+ ")
+\n"
+ "
+\n"
+ "alter table orders
+\n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers
+\n"
+ "alter table line_items
+\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products
+\n"
+ "alter table line_items
+\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr "種々雑多ãªãƒžãƒƒãƒ”ング例"
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr "ã“ã“ã«ã‚る例ã¯ã™ã¹ã¦Hibernateã®ãƒ†ã‚¹ãƒˆã‚¹ã‚¤ãƒ¼ãƒˆã‹ã‚‰å–ã‚Šã¾ã—ãŸã€‚ ãã“ã«ã¯ã€ä»–ã«ã‚‚ãŸãã•ã‚“ã®ãƒžãƒƒãƒ”ングã®ä¾‹ãŒã‚ã‚Šã¾ã™ã€‚ Hibernateディストリビューション㮠<literal>test</literal> フォルダを見ã¦ãã ã•ã„。"
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr "TODO: ã“ã“ã«æ–‡ç« を埋ã‚ã‚‹"
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr "「型付ã‘ã•ã‚ŒãŸã€ä¸€å¯¾ä¸€é–¢é€£"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <id name=\"name\"/>
+\n"
+ " <one-to-one name=\"address\"
+\n"
+ " cascade=\"all\">
+\n"
+ " <formula>name</formula>
+\n"
+ " <formula>'HOME'</formula>
+\n"
+ " </one-to-one>
+\n"
+ " <one-to-one name=\"mailingAddress\"
+\n"
+ " cascade=\"all\">
+\n"
+ " <formula>name</formula>
+\n"
+ " <formula>'MAILING'</formula>
+\n"
+ " </one-to-one>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\" batch-size=\"2\"
+\n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">
+\n"
+ " <composite-id>
+\n"
+ " <key-many-to-one name=\"person\"
+\n"
+ " column=\"personName\"/>
+\n"
+ " <key-property name=\"type\"
+\n"
+ " column=\"addressType\"/>
+\n"
+ " </composite-id>
+\n"
+ " <property name=\"street\" type=\"text\"/>
+\n"
+ " <property name=\"state\"/>
+\n"
+ " <property name=\"zip\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr "複åˆã‚ーã®ä¾‹"
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\">
+\n"
+ "
+\n"
+ " <id name=\"customerId\"
+\n"
+ " length=\"10\">
+\n"
+ " <generator class=\"assigned\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>
+\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>
+\n"
+ "
+\n"
+ " <list name=\"orders\"
+\n"
+ " inverse=\"true\"
+\n"
+ " cascade=\"save-update\">
+\n"
+ " <key column=\"customerId\"/>
+\n"
+ " <index column=\"orderNumber\"/>
+\n"
+ " <one-to-many class=\"Order\"/>
+\n"
+ " </list>
+\n"
+ "
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">
+\n"
+ " <synchronize table=\"LineItem\"/>
+\n"
+ " <synchronize table=\"Product\"/>
+\n"
+ "
+\n"
+ " <composite-id name=\"id\"
+\n"
+ " class=\"Order$Id\">
+\n"
+ " <key-property name=\"customerId\" length=\"10\"/>
+\n"
+ " <key-property name=\"orderNumber\"/>
+\n"
+ " </composite-id>
+\n"
+ "
+\n"
+ " <property name=\"orderDate\"
+\n"
+ " type=\"calendar_date\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " <property name=\"total\">
+\n"
+ " <formula>
+\n"
+ " ( select sum(li.quantity*p.price)
+\n"
+ " from LineItem li, Product p
+\n"
+ " where li.productId = p.productId
+\n"
+ " and li.customerId = customerId
+\n"
+ " and li.orderNumber = orderNumber )
+\n"
+ " </formula>
+\n"
+ " </property>
+\n"
+ "
+\n"
+ " <many-to-one name=\"customer\"
+\n"
+ " column=\"customerId\"
+\n"
+ " insert=\"false\"
+\n"
+ " update=\"false\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " <bag name=\"lineItems\"
+\n"
+ " fetch=\"join\"
+\n"
+ " inverse=\"true\"
+\n"
+ " cascade=\"save-update\">
+\n"
+ " <key>
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " <column name=\"orderNumber\"/>
+\n"
+ " </key>
+\n"
+ " <one-to-many class=\"LineItem\"/>
+\n"
+ " </bag>
+\n"
+ "
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"LineItem\">
+\n"
+ "
+\n"
+ " <composite-id name=\"id\"
+\n"
+ " class=\"LineItem$Id\">
+\n"
+ " <key-property name=\"customerId\" length=\"10\"/>
+\n"
+ " <key-property name=\"orderNumber\"/>
+\n"
+ " <key-property name=\"productId\" length=\"10\"/>
+\n"
+ " </composite-id>
+\n"
+ "
+\n"
+ " <property name=\"quantity\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"order\"
+\n"
+ " insert=\"false\"
+\n"
+ " update=\"false\"
+\n"
+ " not-null=\"true\">
+\n"
+ " <column name=\"customerId\"/>
+\n"
+ " <column name=\"orderNumber\"/>
+\n"
+ " </many-to-one>
+\n"
+ "
+\n"
+ " <many-to-one name=\"product\"
+\n"
+ " insert=\"false\"
+\n"
+ " update=\"false\"
+\n"
+ " not-null=\"true\"
+\n"
+ " column=\"productId\"/>
+\n"
+ "
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Product\">
+\n"
+ " <synchronize table=\"LineItem\"/>
+\n"
+ "
+\n"
+ " <id name=\"productId\"
+\n"
+ " length=\"10\">
+\n"
+ " <generator class=\"assigned\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"description\"
+\n"
+ " not-null=\"true\"
+\n"
+ " length=\"200\"/>
+\n"
+ " <property name=\"price\" length=\"3\"/>
+\n"
+ " <property name=\"numberAvailable\"/>
+\n"
+ "
+\n"
+ " <property name=\"numberOrdered\">
+\n"
+ " <formula>
+\n"
+ " ( select sum(li.quantity)
+\n"
+ " from LineItem li
+\n"
+ " where li.productId = productId )
+\n"
+ " </formula>
+\n"
+ " </property>
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr "複åˆã‚ー属性を共有ã™ã‚‹å¤šå¯¾å¤š"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">
+\n"
+ " <composite-id>
+\n"
+ " <key-property name=\"name\"/>
+\n"
+ " <key-property name=\"org\"/>
+\n"
+ " </composite-id>
+\n"
+ " <set name=\"groups\" table=\"UserGroup\">
+\n"
+ " <key>
+\n"
+ " <column name=\"userName\"/>
+\n"
+ " <column name=\"org\"/>
+\n"
+ " </key>
+\n"
+ " <many-to-many class=\"Group\">
+\n"
+ " <column name=\"groupName\"/>
+\n"
+ " <formula>org</formula>
+\n"
+ " </many-to-many>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Group\" table=\"`Group`\">
+\n"
+ " <composite-id>
+\n"
+ " <key-property name=\"name\"/>
+\n"
+ " <key-property name=\"org\"/>
+\n"
+ " </composite-id>
+\n"
+ " <property name=\"description\"/>
+\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">
+\n"
+ " <key>
+\n"
+ " <column name=\"groupName\"/>
+\n"
+ " <column name=\"org\"/>
+\n"
+ " </key>
+\n"
+ " <many-to-many class=\"User\">
+\n"
+ " <column name=\"userName\"/>
+\n"
+ " <formula>org</formula>
+\n"
+ " </many-to-many>
+\n"
+ " </set>
+\n"
+ "</class>
+\n"
+ "]]>"
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr "discriminationã«åŸºã¥ã内容"
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\"
+\n"
+ " discriminator-value=\"P\">
+\n"
+ "
+\n"
+ " <id name=\"id\"
+\n"
+ " column=\"person_id\"
+\n"
+ " unsaved-value=\"0\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ "
+\n"
+ " <discriminator
+\n"
+ " type=\"character\">
+\n"
+ " <formula>
+\n"
+ " case
+\n"
+ " when title is not null then 'E'
+\n"
+ " when salesperson is not null then 'C'
+\n"
+ " else 'P'
+\n"
+ " end
+\n"
+ " </formula>
+\n"
+ " </discriminator>
+\n"
+ "
+\n"
+ " <property name=\"name\"
+\n"
+ " not-null=\"true\"
+\n"
+ " length=\"80\"/>
+\n"
+ "
+\n"
+ " <property name=\"sex\"
+\n"
+ " not-null=\"true\"
+\n"
+ " update=\"false\"/>
+\n"
+ "
+\n"
+ " <component name=\"address\">
+\n"
+ " <property name=\"address\"/>
+\n"
+ " <property name=\"zip\"/>
+\n"
+ " <property name=\"country\"/>
+\n"
+ " </component>
+\n"
+ "
+\n"
+ " <subclass name=\"Employee\"
+\n"
+ " discriminator-value=\"E\">
+\n"
+ " <property name=\"title\"
+\n"
+ " length=\"20\"/>
+\n"
+ " <property name=\"salary\"/>
+\n"
+ " <many-to-one name=\"manager\"/>
+\n"
+ " </subclass>
+\n"
+ "
+\n"
+ " <subclass name=\"Customer\"
+\n"
+ " discriminator-value=\"C\">
+\n"
+ " <property name=\"comments\"/>
+\n"
+ " <many-to-one name=\"salesperson\"/>
+\n"
+ " </subclass>
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr "代替ã‚ーã®é–¢é€£"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ "
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"hilo\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"name\" length=\"100\"/>
+\n"
+ "
+\n"
+ " <one-to-one name=\"address\"
+\n"
+ " property-ref=\"person\"
+\n"
+ " cascade=\"all\"
+\n"
+ " fetch=\"join\"/>
+\n"
+ "
+\n"
+ " <set name=\"accounts\"
+\n"
+ " inverse=\"true\">
+\n"
+ " <key column=\"userId\"
+\n"
+ " property-ref=\"userId\"/>
+\n"
+ " <one-to-many class=\"Account\"/>
+\n"
+ " </set>
+\n"
+ "
+\n"
+ " <property name=\"userId\" length=\"8\"/>
+\n"
+ "
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Address\">
+\n"
+ "
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"hilo\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"address\" length=\"300\"/>
+\n"
+ " <property name=\"zip\" length=\"5\"/>
+\n"
+ " <property name=\"country\" length=\"25\"/>
+\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>
+\n"
+ "
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Account\">
+\n"
+ " <id name=\"accountId\" length=\"32\">
+\n"
+ " <generator class=\"uuid\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <many-to-one name=\"user\"
+\n"
+ " column=\"userId\"
+\n"
+ " property-ref=\"userId\"/>
+\n"
+ "
+\n"
+ " <property name=\"type\" not-null=\"true\"/>
+\n"
+ "
+\n"
+ "</class>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,401 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr "例：親/åä¾›"
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr "æ–°è¦ãƒ¦ãƒ¼ã‚¶ãŒHibernateを使ã£ã¦ã¾ãšæœ€åˆã«æ‰±ã†ãƒ¢ãƒ‡ãƒ«ã®ä¸€ã¤ã«ã€è¦ªååž‹ã®ãƒ¢ãƒ‡ãƒ«åŒ–ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã®ãƒ¢ãƒ‡ãƒ«åŒ–ã«ã¯äºŒã¤ã®ã‚¢ãƒ—ãƒãƒ¼ãƒãŒå˜åœ¨ã—ã¾ã™ã€‚ã¨ã‚Šã‚ã‘æ–°è¦ãƒ¦ãƒ¼ã‚¶ã«ã¨ã£ã¦ã€ ã•ã¾ã–ã¾ãªç†ç”±ã‹ã‚‰æœ€ã‚‚便利ã ã¨æ€ã‚れるアプãƒãƒ¼ãƒã¯ã€<literal>親</literal> ã‹ã‚‰ <literal>åä¾›</literal> ã¸ã® <literal><one-to-many></literal> 関連ã«ã‚ˆã‚Š <literal>親</literal> 㨠<literal>åä¾›</literal> ã®ä¸¡æ–¹ã‚’エンティティクラスã¨ã—ã¦ãƒ¢ãƒ‡ãƒªãƒ³ã‚°ã™ã‚‹æ–¹æ³•ã§ã™ （もã†ä¸€ã¤ã®æ–¹æ³•ã¯ã€<literal>åä¾›</literal> ã‚’ <literal><composite-element></literal> ã¨ã—ã¦å®šç¾©ã™ã‚‹ã‚‚ã®ã§ã™ï¼‰ã€‚ ã“ã‚Œã§ï¼ˆHibernateã«ãŠã‘る）一対多関連ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ãŒã€é€šå¸¸ã®è¤‡åˆè¦ç´ ã®ãƒžãƒƒãƒ”ングよりも〠親å関係ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‹ã‚‰é ã„ã“ã¨ãŒã‚ã‹ã‚Šã¾ã™ã€‚ ãã‚Œã§ã¯è¦ªå関係を効率的ã!
‹ã¤ã‚¨ãƒ¬ã‚¬ãƒ³ãƒˆã«ãƒ¢ãƒ‡ãƒªãƒ³ã‚°ã™ã‚‹ãŸã‚ã«ã€ <emphasis>カスケードæ“作を使ã£ãŸåŒæ–¹å‘一対多関連</emphasis> ã®æ‰±ã„方を説明ã—ã¾ã™ã€‚ã“ã‚Œã¯ã¾ã£ãŸã難ã—ã„ã‚‚ã®ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr "コレクションã«é–¢ã™ã‚‹æ³¨æ„"
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr "Hibernateã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯è‡ªèº«ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®è«–ç†çš„ãªéƒ¨åˆ†ã¨è€ƒãˆã‚‰ã‚Œã€ 決ã—ã¦åŒ…å«ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ã‚‚ã®ã§ã¯ã‚ã‚Šã¾ã›ã‚“。ã“ã‚Œã¯è‡´å‘½çš„ãªé•ã„ã§ã™ï¼ ã“ã‚Œã¯ä»¥ä¸‹ã®ã‚ˆã†ãªçµæžœã«ãªã‚Šã¾ã™ï¼š"
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr "オブジェクトをコレクションã‹ã‚‰å‰Šé™¤ã€ã¾ãŸã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«è¿½åŠ ã™ã‚‹ã¨ã〠コレクションã®ã‚ªãƒ¼ãƒŠãƒ¼ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã¯ã‚¤ãƒ³ã‚¯ãƒªãƒ¡ãƒ³ãƒˆã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr "ã‚‚ã—コレクションã‹ã‚‰å‰Šé™¤ã•ã‚ŒãŸã‚ªãƒ–ジェクトãŒå€¤åž‹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ （例ãˆã°ã‚³ãƒ³ãƒã‚¸ãƒƒãƒˆã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆ)ã ã£ãŸãªã‚‰ã°ã€ãã®ã‚ªãƒ–ジェクトã¯æ°¸ç¶šçš„ã§ã¯ãªããªã‚Šã€ ãã®çŠ¶æ…‹ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰å®Œå…¨ã«å‰Šé™¤ã•ã‚Œã¾ã™ã€‚ åŒã˜ã‚ˆã†ã«ã€å€¤åž‹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’コレクションã«è¿½åŠ ã™ã‚‹ã¨ã€ãã®çŠ¶æ…‹ã¯ã™ãã«æ°¸ç¶šçš„ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr "一方ã€ã‚‚ã—エンティティãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆä¸€å¯¾å¤šã¾ãŸã¯å¤šå¯¾å¤šé–¢é€£)ã‹ã‚‰å‰Šé™¤ã•ã‚Œã¦ã‚‚〠デフォルトã§ã¯ãã‚Œã¯å‰Šé™¤ã•ã‚Œã¾ã›ã‚“。ã“ã®å‹•ä½œã¯å®Œå…¨ã«ä¸€è²«ã—ã¦ã„ã¾ã™ã€‚ ã™ãªã‚ã¡ã€ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å†…部状態を変更ã—ã¦ã‚‚ã€é–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒæ¶ˆæ»…ã™ã¹ãã§ã¯ãªã„ã¨ã„ã†ã“ã¨ã§ã™ã€‚ åŒæ§˜ã«ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«è¿½åŠ ã•ã‚Œã¦ã‚‚ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯ãã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¯æ°¸ç¶šçš„ã«ã¯ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr "ãã®ä»£ã‚ã‚Šã«ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®å‹•ä½œã§ã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’コレクションã«è¿½åŠ ã™ã‚‹ã¨å˜ã«äºŒã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£é–“ã®ãƒªãƒ³ã‚¯ã‚’作æˆã—〠一方エンティティを削除ã™ã‚‹ã¨ãƒªãƒ³ã‚¯ã‚‚削除ã—ã¾ã™ã€‚ã“ã‚Œã¯ã™ã¹ã¦ã®ã‚±ãƒ¼ã‚¹ã«ãŠã„ã¦éžå¸¸ã«é©åˆ‡ã§ã™ã€‚ ã“ã‚ŒãŒé©åˆ‡ã§ãªã„ã®ã¯è¦ª/å関係ã®å ´åˆã§ã™ã€‚ã“ã®å ´åˆåä¾›ã®ç”Ÿå˜ã¯è¦ªã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã«åˆ¶é™ã•ã‚Œã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr "åŒæ–¹å‘一対多"
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr "<literal>Parent</literal> ã‹ã‚‰ <literal>Child</literal> ã¸ã®å˜ç´”㪠<literal><one-to-many></literal> 関連ã‹ã‚‰å§‹ã‚ã‚‹ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">
+\n"
+ " <key column=\"parent_id\"/>
+\n"
+ " <one-to-many class=\"Child\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr "以下ã®ã‚³ãƒ¼ãƒ‰ã‚’実行ã™ã‚‹ã¨ã€"
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = .....;
+\n"
+ "Child c = new Child();
+\n"
+ "p.getChildren().add(c);
+\n"
+ "session.save(c);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr "Hibernateã¯äºŒã¤ã®SQL文を発行ã—ã¾ã™:"
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr "<literal>c</literal>ã«å¯¾ã™ã‚‹ãƒ¬ã‚³ãƒ¼ãƒ‰ã‚’生æˆã™ã‚‹<literal>INSERT</literal>"
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr "<literal>p</literal>ã‹ã‚‰<literal>c</literal>ã¸ã®ãƒªãƒ³ã‚¯ã‚’作æˆã™ã‚‹<literal>UPDATE</literal>"
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr "ã“ã‚Œã¯éžåŠ¹çŽ‡çš„ãªã ã‘ã§ã¯ãªãã€<literal>parent_id</literal> カラムã«ãŠã„㦠<literal>NOT NULL</literal> 制約ã«é•åã—ã¾ã™ã€‚ コレクションã®ãƒžãƒƒãƒ”ング㧠<literal>not-null=\"true\"</literal> ã¨æŒ‡å®šã™ã‚‹ã“ã¨ã§ã€null制約é•åを解決ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™:"
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">
+\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>
+\n"
+ " <one-to-many class=\"Child\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr "ã—ã‹ã—ã“ã®è§£æ±ºç–ã¯æŽ¨å¥¨ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr "ã“ã®å‹•ä½œã®æ ¹æœ¬çš„ãªåŽŸå› ã¯ã€<literal>p</literal> ã‹ã‚‰ <literal>c</literal> ã¸ã®ãƒªãƒ³ã‚¯ （外部ã‚ー <literal>parent_id</literal>)㯠<literal>Child</literal> オブジェクトã®çŠ¶æ…‹ã®ä¸€éƒ¨ã¨ã¯è€ƒãˆã‚‰ã‚Œãšã€ ãã®ãŸã‚ <literal>INSERT</literal> ã«ã‚ˆã£ã¦ãƒªãƒ³ã‚¯ãŒç”Ÿæˆã•ã‚Œãªã„ã“ã¨ã§ã™ã€‚ ã§ã™ã‹ã‚‰ã€è§£æ±ºç–ã¯ãƒªãƒ³ã‚¯ã‚’Childマッピングã®ä¸€éƒ¨ã«ã™ã‚‹ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr "(ã¾ãŸ <literal>Child</literal> クラス㫠<literal>parent</literal> プãƒãƒ‘ãƒ†ã‚£ã‚’è¿½åŠ ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚)"
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr "ãã‚Œã§ã¯ <literal>Child</literal> エンティティãŒãƒªãƒ³ã‚¯ã®çŠ¶æ…‹ã‚’制御ã™ã‚‹ã‚ˆã†ã«ãªã£ãŸã®ã§ã€ コレクションãŒãƒªãƒ³ã‚¯ã‚’æ›´æ–°ã—ãªã„よã†ã«ã—ã¾ã—ょã†ã€‚ãã‚Œã«ã¯ <literal>inverse</literal> 属性を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">
+\n"
+ " <key column=\"parent_id\"/>
+\n"
+ " <one-to-many class=\"Child\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr "以下ã®ã‚³ãƒ¼ãƒ‰ã‚’使ãˆã°ã€æ–°ã—ã„ <literal>Child</literal> ã‚’è¿½åŠ ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "Child c = new Child();
+\n"
+ "c.setParent(p);
+\n"
+ "p.getChildren().add(c);
+\n"
+ "session.save(c);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr "ã“ã‚Œã«ã‚ˆã‚Šã€SQLã® <literal>INSERT</literal> æ–‡ãŒä¸€ã¤ã ã‘ãŒç™ºè¡Œã•ã‚Œã‚‹ã‚ˆã†ã«ãªã‚Šã¾ã—ãŸï¼"
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr "ã‚‚ã†å°‘ã—強化ã™ã‚‹ã«ã¯ã€<literal>Parent</literal> ã® <literal>addChild()</literal> メソッドを作æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public void addChild(Child c) {
+\n"
+ " c.setParent(this);
+\n"
+ " children.add(c);
+\n"
+ "}]]>"
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr "<literal>Child</literal> ã‚’è¿½åŠ ã™ã‚‹ã‚³ãƒ¼ãƒ‰ã¯ã“ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "Child c = new Child();
+\n"
+ "p.addChild(c);
+\n"
+ "session.save(c);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr "ライフサイクルã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰"
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr "明示的㫠<literal>save()</literal> をコールã™ã‚‹ã®ã¯ã¾ã ç…©ã‚ã—ã„ã‚‚ã®ã§ã™ã€‚ã“れをカスケードを使ã£ã¦å¯¾å‡¦ã—ã¾ã™ã€‚"
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">
+\n"
+ " <key column=\"parent_id\"/>
+\n"
+ " <one-to-many class=\"Child\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr "ã“ã‚Œã«ã‚ˆã‚Šå…ˆã»ã©ã®ã‚³ãƒ¼ãƒ‰ã‚’ã“ã®ã‚ˆã†ã«å˜ç´”化ã—ã¾ã™"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "Child c = new Child();
+\n"
+ "p.addChild(c);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr "åŒæ§˜ã« <literal>Parent</literal> ã‚’ä¿å˜ã¾ãŸã¯å‰Šé™¤ã™ã‚‹ã¨ãã«ã€å供を一ã¤ä¸€ã¤å–り出ã—ã¦æ‰±ã†å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 以下ã®ã‚³ãƒ¼ãƒ‰ã¯ <literal>p</literal> を削除ã—ã€ãã—ã¦ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰ãã®å供をã™ã¹ã¦å‰Šé™¤ã—ã¾ã™ã€‚"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "session.delete(p);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr "ã—ã‹ã—ã“ã®ã‚³ãƒ¼ãƒ‰ã¯"
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "Child c = (Child) p.getChildren().iterator().next();
+\n"
+ "p.getChildren().remove(c);
+\n"
+ "c.setParent(null);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr "データベースã‹ã‚‰ <literal>c</literal> を削除ã—ã¾ã›ã‚“。<literal>p</literal> ã¸ã®ãƒªãƒ³ã‚¯ã‚’削除ã™ã‚‹ （ãã—ã¦ã“ã®ã‚±ãƒ¼ã‚¹ã§ã¯ <literal>NOT NULL</literal> 制約é•åを引ãèµ·ã“ã™ï¼‰ã ã‘ã§ã™ã€‚ <literal>Child</literal> ã® <literal>delete()</literal> を明示ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
+\n"
+ "Child c = (Child) p.getChildren().iterator().next();
+\n"
+ "p.getChildren().remove(c);
+\n"
+ "session.delete(c);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr "今ã“ã®ã‚±ãƒ¼ã‚¹ã§ã¯å®Ÿéš›ã« <literal>Child</literal> ãŒè¦ªãªã—ã§ã¯å˜åœ¨ã§ããªã„よã†ã«ãªã‚Šã¾ã—ãŸã€‚ ãã®ãŸã‚ã€ã‚‚ã—コレクションã‹ã‚‰ <literal>Child</literal> ã‚’å–り除ãå ´åˆã€ã“れも削除ã—ãŸã„ã§ã™ã€‚ ãã®ãŸã‚ã«ã¯ <literal>cascade=\"all-delete-orphan\"</literal> を使ã‚ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">
+\n"
+ " <key column=\"parent_id\"/>
+\n"
+ " <one-to-many class=\"Child\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr "注æ„：コレクションã®ãƒžãƒƒãƒ”ング㧠<literal>inverse=\"true\"</literal> ã¨æŒ‡å®šã—ã¦ã‚‚〠コレクションã®è¦ç´ ã®ã‚¤ãƒ†ãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³ã«ã‚ˆã£ã¦ã€ä¾ç„¶ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ãŒå®Ÿè¡Œã•ã‚Œã¾ã™ã€‚ ãã®ãŸã‚ã‚‚ã—カスケードã§ã‚ªãƒ–ジェクトをセーブã€å‰Šé™¤ã€æ›´æ–°ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãªã‚‰ã€ ãれをコレクションã«è¿½åŠ ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。å˜ã« <literal>setParent()</literal> を呼ã¶ã ã‘ã§ã¯ä¸å分ã§ã™ã€‚"
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr "カスケード㨠<literal>unsaved-value</literal>"
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr "<literal>Parent</literal> ãŒã€ã‚ã‚‹ <literal>Session</literal> ã§ãƒãƒ¼ãƒ‰ã•ã‚Œã€UIã®ã‚¢ã‚¯ã‚·ãƒ§ãƒ³ã§å¤‰æ›´ãŒåŠ ãˆã‚‰ã‚Œã€ <literal>update()</literal> を呼んã§ã“ã®å¤‰æ›´ã‚’æ–°ã—ã„セッションã§æ°¸ç¶šåŒ–ã—ãŸã„ã¨ã—ã¾ã™ã€‚ <literal>Parent</literal> ãŒåä¾›ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’æŒã¡ã€ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰æ›´æ–°ãŒæœ‰åŠ¹ã«ãªã£ã¦ã„ã‚‹ãŸã‚〠Hibernateã¯ã©ã®åä¾›ãŒæ–°ã—ãインスタンス化ã•ã‚ŒãŸã‹ã€ã©ã‚ŒãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®æ—¢å˜ã®è¡Œã«ç›¸å½“ã™ã‚‹ã®ã‹ã‚’知る必è¦ãŒã‚ã‚Šã¾ã™ã€‚ <literal>Parent</literal> 㨠<literal>Child</literal> ã®ä¸¡æ–¹ãŒ <literal>java.lang.Long</literal> åž‹ã®è˜åˆ¥ãƒ—ãƒãƒ‘ティを生æˆã—ãŸã¨ã—ã¾ã—ょã†ã€‚ Hibernateã¯ã©ã®åä¾›ãŒæ–°ã—ã„ã‚‚ã®ã‹ã‚’決定ã™ã‚‹ãŸã‚ã«è˜åˆ¥ãƒ—ãƒãƒ‘ティã®å€¤ã‚’使ã„ã¾ã™(versionã‚„timestampプãƒãƒ‘ティも使ãˆã¾ã™ã€‚ <xref linkend=\"manipulatingdata-updating-detached\"/> å‚ç…§)。Hibernate3ã«ãªã£ã¦ã€ 明示的ã«!
<literal>unsaved-value</literal> を指定ã™ã‚‹å¿…è¦ã¯ãªããªã‚Šã¾ã—ãŸã€‚"
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr "以下ã®ã‚³ãƒ¼ãƒ‰ã¯ <literal>parent</literal> 㨠<literal>child</literal> ã‚’æ›´æ–°ã—ã€<literal>newChild</literal> を挿入ã—ã¾ã™ã€‚"
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[//parent and child were both loaded in a previous session
+\n"
+ "//parentã¨childã¯ä¸¡æ–¹ã¨ã‚‚ã€ä»¥å‰ã®Sessionã§ãƒãƒ¼ãƒ‰ã•ã‚Œã¦ã„ã¾ã™
+\n"
+ "parent.addChild(child);
+\n"
+ "Child newChild = new Child();
+\n"
+ "parent.addChild(newChild);
+\n"
+ "session.update(parent);
+\n"
+ "session.flush();]]>"
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr "ã“れらã¯ç”Ÿæˆã•ã‚ŒãŸè˜åˆ¥åã®å ´åˆã«ã¯éžå¸¸ã«è‰¯ã„ã®ã§ã™ãŒã€å‰²ã‚Šå½“ã¦ã‚‰ã‚ŒãŸè˜åˆ¥åã¨è¤‡åˆè˜åˆ¥åã®å ´åˆã¯ã©ã†ã§ã—ょã†ã‹ï¼Ÿ ã“ã‚Œã¯HibernateãŒã€ï¼ˆãƒ¦ãƒ¼ã‚¶ã«ã‚ˆã‚Šå‰²ã‚Šå½“ã¦ã‚‰ã‚ŒãŸè˜åˆ¥åã‚’æŒã¤ï¼‰æ–°ã—ãインスタンス化ã•ã‚ŒãŸã‚ªãƒ–ジェクトã¨ã€ 以å‰ã®Sessionã§ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã‚ªãƒ–ジェクトを区別ã§ããªã„ãŸã‚ã€ã‚ˆã‚Šé›£ã—ã„ã§ã™ã€‚ ã“ã®å ´åˆã€Hibernateã¯ã‚¿ã‚¤ãƒ スタンプã‹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ãƒ—ãƒãƒ‘ティã®ã©ã¡ã‚‰ã‹ã‚’使ã†ã‹ã€äºŒæ¬¡ã‚ャッシュã«å•ã„åˆã‚ã›ã¾ã™ã€‚ 最悪ã®å ´åˆã€è¡ŒãŒå˜åœ¨ã™ã‚‹ã‹ã©ã†ã‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’見ã¾ã™ã€‚"
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr "<title>çµè«–</title>"
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr "ã“ã“ã§ã¯ã‹ãªã‚Šã®é‡ã‚’è¦ç´„ã—ãŸã®ã§ã€æœ€åˆã®é ƒã¯æ··ä¹±ã—ã¦ã„るよã†ã«æ€ã‚れるã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã—ã‹ã—実際ã¯ã€ã™ã¹ã¦éžå¸¸ã«è‰¯ã動作ã—ã¾ã™ã€‚ã»ã¨ã‚“ã©ã®Hibernateアプリケーションã§ã¯ã€å¤šãã®å ´é¢ã§è¦ªåパターンを使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr "最åˆã®æ®µè½ã§ä»£æ›¿æ–¹æ³•ã«ã¤ã„ã¦è§¦ã‚Œã¾ã—ãŸã€‚上記ã®ã‚ˆã†ãªå•é¡Œã¯ <literal><composite-element></literal> マッピングã®å ´åˆã¯å˜åœ¨ã›ãšã€ ã«ã‚‚ã‹ã‹ã‚らãšãã‚Œã¯ç¢ºã‹ã«è¦ªå関係ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’æŒã¡ã¾ã™ã€‚ ã—ã‹ã—残念ãªãŒã‚‰ã€è¤‡åˆè¦ç´ クラスã«ã¯äºŒã¤ã®å¤§ããªåˆ¶é™ãŒã‚ã‚Šã¾ã™ï¼š 1ã¤ã¯è¤‡åˆè¦ç´ ã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’æŒã¤ã“ã¨ãŒã§ããªã„ã“ã¨ã§ã™ã€‚ã‚‚ã†ã²ã¨ã¤ã¯ã€ ユニークãªè¦ªã§ã¯ãªã„エンティティã®åä¾›ã¨ãªã‚‹ã¹ãã§ã¯ãªã„ã¨ã„ã†ã“ã¨ã§ã™"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1225 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr "例: Weblogアプリケーション"
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr "永続クラス"
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr "永続クラスãŒã‚¦ã‚§ãƒ–ãƒã‚°ã¨ã€ã‚¦ã‚§ãƒ–ãƒã‚°ã«æŽ²ç¤ºã•ã‚ŒãŸé …目を表ã—ã¦ã„ã¾ã™ã€‚ ãれらã¯é€šå¸¸ã®è¦ªå関係ã¨ã—ã¦ãƒ¢ãƒ‡ãƒªãƒ³ã‚°ã•ã‚Œã¾ã™ãŒã€ setã§ã¯ãªãé †åºã‚’æŒã£ãŸbagを使用ã™ã‚‹ã“ã¨ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "
+\n"
+ "import java.util.List;
+\n"
+ "
+\n"
+ "public class Blog {
+\n"
+ " private Long _id;
+\n"
+ " private String _name;
+\n"
+ " private List _items;
+\n"
+ "
+\n"
+ " public Long getId() {
+\n"
+ " return _id;
+\n"
+ " }
+\n"
+ " public List getItems() {
+\n"
+ " return _items;
+\n"
+ " }
+\n"
+ " public String getName() {
+\n"
+ " return _name;
+\n"
+ " }
+\n"
+ " public void setId(Long long1) {
+\n"
+ " _id = long1;
+\n"
+ " }
+\n"
+ " public void setItems(List list) {
+\n"
+ " _items = list;
+\n"
+ " }
+\n"
+ " public void setName(String string) {
+\n"
+ " _name = string;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "
+\n"
+ "import java.text.DateFormat;
+\n"
+ "import java.util.Calendar;
+\n"
+ "
+\n"
+ "public class BlogItem {
+\n"
+ " private Long _id;
+\n"
+ " private Calendar _datetime;
+\n"
+ " private String _text;
+\n"
+ " private String _title;
+\n"
+ " private Blog _blog;
+\n"
+ "
+\n"
+ " public Blog getBlog() {
+\n"
+ " return _blog;
+\n"
+ " }
+\n"
+ " public Calendar getDatetime() {
+\n"
+ " return _datetime;
+\n"
+ " }
+\n"
+ " public Long getId() {
+\n"
+ " return _id;
+\n"
+ " }
+\n"
+ " public String getText() {
+\n"
+ " return _text;
+\n"
+ " }
+\n"
+ " public String getTitle() {
+\n"
+ " return _title;
+\n"
+ " }
+\n"
+ " public void setBlog(Blog blog) {
+\n"
+ " _blog = blog;
+\n"
+ " }
+\n"
+ " public void setDatetime(Calendar calendar) {
+\n"
+ " _datetime = calendar;
+\n"
+ " }
+\n"
+ " public void setId(Long long1) {
+\n"
+ " _id = long1;
+\n"
+ " }
+\n"
+ " public void setText(String string) {
+\n"
+ " _text = string;
+\n"
+ " }
+\n"
+ " public void setTitle(String string) {
+\n"
+ " _title = string;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr "Hibernateã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr "XMLマッピングã¯ã€ä»Šã§ã¯ã¨ã¦ã‚‚ç°¡å˜ãªã¯ãšã§ã™ã€‚"
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>
+\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">
+\n"
+ "
+\n"
+ "<hibernate-mapping package=\"eg\">
+\n"
+ "
+\n"
+ " <class
+\n"
+ " name=\"Blog\"
+\n"
+ " table=\"BLOGS\">
+\n"
+ "
+\n"
+ " <id
+\n"
+ " name=\"id\"
+\n"
+ " column=\"BLOG_ID\">
+\n"
+ "
+\n"
+ " <generator class=\"native\"/>
+\n"
+ "
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property
+\n"
+ " name=\"name\"
+\n"
+ " column=\"NAME\"
+\n"
+ " not-null=\"true\"
+\n"
+ " unique=\"true\"/>
+\n"
+ "
+\n"
+ " <bag
+\n"
+ " name=\"items\"
+\n"
+ " inverse=\"true\"
+\n"
+ " order-by=\"DATE_TIME\"
+\n"
+ " cascade=\"all\">
+\n"
+ "
+\n"
+ " <key column=\"BLOG_ID\"/>
+\n"
+ " <one-to-many class=\"BlogItem\"/>
+\n"
+ "
+\n"
+ " </bag>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>
+\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">
+\n"
+ "
+\n"
+ "<hibernate-mapping package=\"eg\">
+\n"
+ "
+\n"
+ " <class
+\n"
+ " name=\"BlogItem\"
+\n"
+ " table=\"BLOG_ITEMS\"
+\n"
+ " dynamic-update=\"true\">
+\n"
+ "
+\n"
+ " <id
+\n"
+ " name=\"id\"
+\n"
+ " column=\"BLOG_ITEM_ID\">
+\n"
+ "
+\n"
+ " <generator class=\"native\"/>
+\n"
+ "
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property
+\n"
+ " name=\"title\"
+\n"
+ " column=\"TITLE\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " <property
+\n"
+ " name=\"text\"
+\n"
+ " column=\"TEXT\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " <property
+\n"
+ " name=\"datetime\"
+\n"
+ " column=\"DATE_TIME\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " <many-to-one
+\n"
+ " name=\"blog\"
+\n"
+ " column=\"BLOG_ID\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr "Hibernateã®ã‚³ãƒ¼ãƒ‰"
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr "以下ã®ã‚¯ãƒ©ã‚¹ã¯ã€ Hibernateã§ã“れらã®ã‚¯ãƒ©ã‚¹ã‚’使ã£ã¦ã§ãã‚‹ã“ã¨ã‚’ã„ãã¤ã‹ç¤ºã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "
+\n"
+ "import java.util.ArrayList;
+\n"
+ "import java.util.Calendar;
+\n"
+ "import java.util.Iterator;
+\n"
+ "import java.util.List;
+\n"
+ "
+\n"
+ "import org.hibernate.HibernateException;
+\n"
+ "import org.hibernate.Query;
+\n"
+ "import org.hibernate.Session;
+\n"
+ "import org.hibernate.SessionFactory;
+\n"
+ "import org.hibernate.Transaction;
+\n"
+ "import org.hibernate.cfg.Configuration;
+\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;
+\n"
+ "
+\n"
+ "public class BlogMain {
+\n"
+ "
+\n"
+ " private SessionFactory _sessions;
+\n"
+ "
+\n"
+ " public void configure() throws HibernateException {
+\n"
+ " _sessions = new Configuration()
+\n"
+ " .addClass(Blog.class)
+\n"
+ " .addClass(BlogItem.class)
+\n"
+ " .buildSessionFactory();
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void exportTables() throws HibernateException {
+\n"
+ " Configuration cfg = new Configuration()
+\n"
+ " .addClass(Blog.class)
+\n"
+ " .addClass(BlogItem.class);
+\n"
+ " new SchemaExport(cfg).create(true, true);
+\n"
+ " }
+\n"
+ "
+\n"
+ " public Blog createBlog(String name) throws HibernateException {
+\n"
+ "
+\n"
+ " Blog blog = new Blog();
+\n"
+ " blog.setName(name);
+\n"
+ " blog.setItems( new ArrayList() );
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " session.persist(blog);
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return blog;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " BlogItem item = new BlogItem();
+\n"
+ " item.setTitle(title);
+\n"
+ " item.setText(text);
+\n"
+ " item.setBlog(blog);
+\n"
+ " item.setDatetime( Calendar.getInstance() );
+\n"
+ " blog.getItems().add(item);
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " session.update(blog);
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return item;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " BlogItem item = new BlogItem();
+\n"
+ " item.setTitle(title);
+\n"
+ " item.setText(text);
+\n"
+ " item.setDatetime( Calendar.getInstance() );
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);
+\n"
+ " item.setBlog(blog);
+\n"
+ " blog.getItems().add(item);
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return item;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void updateBlogItem(BlogItem item, String text)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " item.setText(text);
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " session.update(item);
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void updateBlogItem(Long itemid, String text)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);
+\n"
+ " item.setText(text);
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " }
+\n"
+ "
+\n"
+ " public List listAllBlogNamesAndItemCounts(int max)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " List result = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " Query q = session.createQuery(
+\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +
+\n"
+ " \"from Blog as blog \" +
+\n"
+ " \"left outer join blog.items as blogItem \" +
+\n"
+ " \"group by blog.name, blog.id \" +
+\n"
+ " \"order by max(blogItem.datetime)\"
+\n"
+ " );
+\n"
+ " q.setMaxResults(max);
+\n"
+ " result = q.list();
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return result;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public Blog getBlogAndAllItems(Long blogid)
+\n"
+ " throws HibernateException {
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " Blog blog = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " Query q = session.createQuery(
+\n"
+ " \"from Blog as blog \" +
+\n"
+ " \"left outer join fetch blog.items \" +
+\n"
+ " \"where blog.id = :blogid\"
+\n"
+ " );
+\n"
+ " q.setParameter(\"blogid\", blogid);
+\n"
+ " blog = (Blog) q.uniqueResult();
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return blog;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public List listBlogsAndRecentItems() throws HibernateException {
+\n"
+ "
+\n"
+ " Session session = _sessions.openSession();
+\n"
+ " Transaction tx = null;
+\n"
+ " List result = null;
+\n"
+ " try {
+\n"
+ " tx = session.beginTransaction();
+\n"
+ " Query q = session.createQuery(
+\n"
+ " \"from Blog as blog \" +
+\n"
+ " \"inner join blog.items as blogItem \" +
+\n"
+ " \"where blogItem.datetime > :minDate\"
+\n"
+ " );
+\n"
+ "
+\n"
+ " Calendar cal = Calendar.getInstance();
+\n"
+ " cal.roll(Calendar.MONTH, false);
+\n"
+ " q.setCalendar(\"minDate\", cal);
+\n"
+ "
+\n"
+ " result = q.list();
+\n"
+ " tx.commit();
+\n"
+ " }
+\n"
+ " catch (HibernateException he) {
+\n"
+ " if (tx!=null) tx.rollback();
+\n"
+ " throw he;
+\n"
+ " }
+\n"
+ " finally {
+\n"
+ " session.close();
+\n"
+ " }
+\n"
+ " return result;
+\n"
+ " }
+\n"
+ "}]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,234 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr "データã®ãƒ•ã‚£ãƒ«ã‚¿ãƒªãƒ³ã‚°"
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr "Hibernate3ã§ã¯ã€Œå¯è¦–性ã€ãƒ«ãƒ¼ãƒ«ã«åŸºã¥ã„ã¦ãƒ‡ãƒ¼ã‚¿ã‚’扱ã†ãŸã‚ã®ç”»æœŸçš„ãªæ–¹æ³•ã‚’用æ„ã—ã¦ã„ã¾ã™ã€‚ <emphasis>Hibernate filter</emphasis> ã¯ã‚°ãƒãƒ¼ãƒãƒ«ã§ã€åå‰ä»˜ãã§ã€ãƒ‘ラメータ化ã•ã‚ŒãŸãƒ•ã‚£ãƒ«ã‚¿ã§ã™ã€‚ ã“ã‚Œã¯Hibernateセッションã”ã¨ã«æœ‰åŠ¹ç„¡åŠ¹ã‚’切り替ãˆã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr "Hibernateã®ãƒ•ã‚£ãƒ«ã‚¿"
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr "Hibernate3ã¯ãƒ•ã‚£ãƒ«ã‚¿ã‚¯ãƒ©ã‚¤ãƒ†ãƒªã‚¢ã‚’ã‚らã‹ã˜ã‚定義ã—〠ã“れらã®ãƒ•ã‚£ãƒ«ã‚¿ã‚’クラスやコレクションレベルã«åŠ ãˆã‚‹æ©Ÿèƒ½ã‚’åŠ ãˆã¾ã—ãŸã€‚ フィルタクライテリアã¯åˆ¶ç´„節を定義ã™ã‚‹æ©Ÿèƒ½ã§ã™ã€‚ ã“れらã®ãƒ•ã‚£ãƒ«ã‚¿æ¡ä»¶ã¯ãƒ‘ラメータ化ã§ãã‚‹ã¨ã„ã†ã“ã¨ã‚’除ã〠クラスやã•ã¾ã–ã¾ãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³è¦ç´ ã§åˆ©ç”¨å¯èƒ½ãªï½¢whereï½£å¥ã«éžå¸¸ã«ã‚ˆãä¼¼ã¦ã„ã¾ã™ã€‚ アプリケーションã¯ã€ä¸Žãˆã‚‰ã‚ŒãŸãƒ•ã‚£ãƒ«ã‚¿ã‚’å¯èƒ½ã«ã™ã¹ãã‹ã€ ãã—ã¦ãã®ãƒ‘ラメータ値を何ã«ã™ã¹ãã‹ã‚’実行時ã«æ±ºå®šã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ フィルタã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ“ューã®ã‚ˆã†ã«ä½¿ç”¨ã•ã‚Œã¾ã™ãŒã€ã‚¢ãƒ—リケーション内ã§ã¯ãƒ‘ラメータ化ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr "フィルタを使ã†ãŸã‚ã«ã¯ã¾ãšã€é©åˆ‡ãªãƒžãƒƒãƒ”ングè¦ç´ ã«å®šç¾©ã€è¿½åŠ ã—ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。 フィルタを定義ã™ã‚‹ãŸã‚ã«ã¯ã€ <literal><hibernate-mapping/></literal> è¦ç´ 内㧠<literal><filter-def/></literal> è¦ç´ を使用ã—ã¾ã™ã€‚："
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"myFilter\">
+\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>
+\n"
+ "</filter-def>]]>"
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr "ãã†ã—ã¦ãƒ•ã‚£ãƒ«ã‚¿ã¯ã‚¯ãƒ©ã‚¹ã¸ã¨çµã³ä»˜ã‘られã¾ã™ã€‚："
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"myClass\" ...>
+\n"
+ " ...
+\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr "ã¾ãŸã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã—ã¦ã¯æ¬¡ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚："
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set ...>
+\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr "ã©ã¡ã‚‰ã«å¯¾ã—ã¦ã‚‚(ã¾ãŸã€ãã‚Œãžã‚Œã‚’複数)åŒæ™‚ã«è¨å®šã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr "<literal>Session</literal> 上ã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, <literal>disableFilter(String filterName)</literal> ã§ã™ã€‚ デフォルトã§ã¯ã€ãƒ•ã‚£ãƒ«ã‚¿ã¯ä¸Žãˆã‚‰ã‚ŒãŸã‚»ãƒƒã‚·ãƒ§ãƒ³ã«å¯¾ã—ã¦ä½¿ç”¨ <emphasis>ã§ãã¾ã›ã‚“</emphasis> 。 <literal>Filter</literal> インスタンスを返り値ã¨ã™ã‚‹ <literal>Session.enabledFilter()</literal> メソッドを使ã†ã“ã¨ã§ã€ フィルタã¯æ˜Žç¤ºçš„ã«ä½¿ç”¨å¯èƒ½ã¨ãªã‚Šã¾ã™ã€‚ 上ã§å®šç¾©ã—ãŸå˜ç´”ãªãƒ•ã‚£ãƒ«ã‚¿ã®ä½¿ç”¨ã¯ã€ã“ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚："
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr "org.hibernate.Filterインターフェイスã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ã€ Hibernateã®å¤šãã«å…±é€šã—ã¦ã„るメソッド連鎖を許ã—ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr "有効ãªãƒ¬ã‚³ãƒ¼ãƒ‰ãƒ‡ãƒ¼ã‚¿ãƒ‘ターンをæŒã¤ä¸€æ™‚データを使ã£ãŸå®Œå…¨ãªä¾‹ã§ã™ï¼š"
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">
+\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>
+\n"
+ "</filter-def>
+\n"
+ "
+\n"
+ "<class name=\"Employee\" ...>
+\n"
+ "...
+\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>
+\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>
+\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>
+\n"
+ "...
+\n"
+ " <!--
+\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to
+\n"
+ " a max db date for simplicity-sake
+\n"
+ "
+\n"
+ "
+\n"
+ " -->
+\n"
+ " <filter name=\"effectiveDate\"
+\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>
+\n"
+ "</class>
+\n"
+ "
+\n"
+ "<class name=\"Department\" ...>
+\n"
+ "...
+\n"
+ " <set name=\"employees\" lazy=\"true\">
+\n"
+ " <key column=\"dept_id\"/>
+\n"
+ " <one-to-many class=\"Employee\"/>
+\n"
+ " <filter name=\"effectiveDate\"
+\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr "常ã«ç¾åœ¨ã®æœ‰åŠ¹ãƒ¬ã‚³ãƒ¼ãƒ‰ã‚’è¿”å´ã™ã‚‹ã“ã¨ã‚’ä¿è¨¼ã™ã‚‹ãŸã‚ã«ã€ å˜ç´”ã«ã€ç¤¾å“¡ãƒ‡ãƒ¼ã‚¿ã®æ¤œç´¢ã‚ˆã‚Šå‰ã«ã‚»ãƒƒã‚·ãƒ§ãƒ³ä¸Šã®ãƒ•ã‚£ãƒ«ã‚¿ã‚’有効ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session session = ...;
+\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());
+\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")
+\n"
+ " .setLong(\"targetSalary\", new Long(1000000))
+\n"
+ " .list();
+\n"
+ "]]>"
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr "上記ã®HQLã§ã¯ã€çµæžœã®çµ¦æ–™ã®åˆ¶ç´„ã«ã¤ã„ã¦æ˜Žç¤ºçš„ã«è§¦ã‚ŒãŸã ã‘ã§ã™ãŒã€ 有効ã«ãªã£ã¦ã„るフィルタã®ãŠã‹ã’ã§ã€ã“ã®ã‚¯ã‚¨ãƒªã¯çµ¦æ–™ãŒ100万ドル以上ã®ç¾å½¹ã®ç¤¾å“¡ã ã‘ã‚’è¿”ã—ã¾ã™ã€‚"
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr "(HQLã‹ãƒãƒ¼ãƒ‰ãƒ•ã‚§ãƒƒãƒã§ï¼‰å¤–部çµåˆã‚’æŒã¤ãƒ•ã‚£ãƒ«ã‚¿ã‚’使ã†ã¤ã‚‚ã‚Šãªã‚‰ã€ æ¡ä»¶å¼ã®æ–¹å‘ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã‚Œã¯å·¦å¤–部çµåˆã®ãŸã‚ã«è¨å®šã™ã‚‹ã®ãŒæœ€ã‚‚安全ã§ã™ã€‚ 一般的ã«ã€æ¼”ç®—åã®å¾Œã‚«ãƒ©ãƒ åã«ç¶šã‘ã¦æœ€åˆã®ãƒ‘ラメータをé…ç½®ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,642 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr "継承マッピング"
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr "3ã¤ã®æˆ¦ç•¥"
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr "Hibernateã¯3ã¤ã®åŸºæœ¬çš„ãªç¶™æ‰¿ã®ãƒžãƒƒãƒ”ング戦略をサãƒãƒ¼ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr "<para>クラス階層ã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-class-hierarchy）</para>"
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr "<para>サブクラスã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-subclass）</para>"
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr "<para>具象クラスã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-concrete-class）</para>"
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr "åŠ ãˆã¦4ã¤ç›®ã«ã€Hibernateã¯ã‚ãšã‹ã«ç•°ãªã‚‹æ€§è³ªã‚’æŒã£ãŸãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ をサãƒãƒ¼ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr "暗黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ "
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr "åŒä¸€ã®ç¶™æ‰¿éšŽå±¤ã®ç•°ãªã‚‹ãƒ–ランãƒã«å¯¾ã—ã¦ç•°ãªã‚‹ãƒžãƒƒãƒ”ング戦略を使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ ãã®å ´åˆã«ã¯å…¨ä½“ã®éšŽå±¤ã«æ¸¡ã‚‹ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を実ç¾ã™ã‚‹ãŸã‚ã«æš—黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を使用ã—ã¾ã™ã€‚ ã—ã‹ã—ã€Hibernateã¯åŒã˜ãƒ«ãƒ¼ãƒˆ <literal><class></literal> è¦ç´ 内㧠<literal><subclass></literal> マッピングã€<literal><joined-subclass></literal> マッピング〠<literal><union-subclass></literal> マッピングã®åŒæ™‚使用をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“。 <literal><subclass></literal> è¦ç´ 㨠<literal><join></literal> è¦ç´ を組ã¿åˆã‚ã›ã‚‹ã“ã¨ã§ã€ åŒä¸€ <literal><class></literal> è¦ç´ 内ã§ã® table-per-hierarchy 戦略㨠table-per-subclass 戦略ã®åŒæ™‚使用ã¯å¯èƒ½ã§ã™ã€‚次ã®ä¾‹ã‚’見ã¦ãã ã•ã„。"
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr "<literal>subclass</literal>, <literal>union-subclass</literal> 㨠<literal>joined-subclass</literal> マッピングを複数ã®ãƒžãƒƒãƒ”ングドã‚ュメントã«å®šç¾©ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã€ <literal>hibernate-mapping</literal> ã®ç›´ä¸‹ã«é…ç½®ã—ã¾ã™ã€‚ ã“ã‚Œã¯æ–°ã—ã„ãƒžãƒƒãƒ”ãƒ³ã‚°ãƒ•ã‚¡ã‚¤ãƒ«ã‚’è¿½åŠ ã™ã‚‹ã ã‘ã§ã€ã‚¯ãƒ©ã‚¹éšŽå±¤ã‚’æ‹¡å¼µã§ãã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ã‚らã‹ã˜ã‚マップã—ãŸã‚¹ãƒ¼ãƒ‘ークラスを指定ã—ã¦ã€ã‚µãƒ–クラスマッピング㫠<literal>extends</literal> 属性を記述ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 注æ„：ã“ã®ç‰¹å¾´ã«ã‚ˆã‚Šã€ä»¥å‰ã¯ãƒžãƒƒãƒ”ング・ドã‚ュメントã®é †ç•ªãŒé‡è¦ã§ã—ãŸã€‚ Hibernate3ã‹ã‚‰ã¯ã€extendsã‚ーワードを使ã†å ´åˆã€ãƒžãƒƒãƒ”ングドã‚ュメントã®é †ç•ªã¯å•é¡Œã«ãªã‚Šã¾ã›ã‚“。 １ã¤ã®ãƒžãƒƒãƒ”ングファイル内ã§é †ç•ªä»˜ã‘ã‚’è¡Œã†ã¨ãã¯ã€ ä¾ç„¶ã¨ã—ã¦ã€ã‚µãƒ–クラスを定義ã™ã‚‹å‰ã«ã‚¹ãƒ¼ãƒ‘ークラスを定義ã™!
ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚)"
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr "<title>クラス階層ã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-class-hierarchy）</title>"
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr "例ãˆã°ã€ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ <literal>Payment</literal> ã¨ã€ãれを実装ã—㟠<literal>CreditCardPayment</literal>ã€<literal>CashPayment</literal>〠<literal>ChequePayment</literal> ãŒã‚ã‚‹ã¨ã—ã¾ã™ã€‚階層ã”ã¨ã®ãƒ†ãƒ¼ãƒ–ルマッピング㯠以下ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr "ã¡ã‚‡ã†ã©ä¸€ã¤ã®ãƒ†ãƒ¼ãƒ–ルãŒå¿…è¦ã§ã™ã€‚ ã“ã®ãƒžãƒƒãƒ”ング戦略ã«ã¯ä¸€ã¤å¤§ããªåˆ¶é™ãŒã‚ã‚Šã¾ã™ã€‚ <literal>CCTYPE</literal> ã®ã‚ˆã†ãªã€ã‚µãƒ–クラスã§å®£è¨€ã•ã‚ŒãŸã‚«ãƒ©ãƒ 㯠<literal>NOT NULL</literal> 制約をæŒã¦ã¾ã›ã‚“。"
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr "<title>サブクラスã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-subclass）</title>"
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr "table-per-subclass マッピングã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:102
+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 "ã“ã®ãƒžãƒƒãƒ”ングã«ã¯4ã¤ã®ãƒ†ãƒ¼ãƒ–ルãŒå¿…è¦ã§ã™ã€‚3ã¤ã®ã‚µãƒ–クラステーブル㯠スーパークラステーブルã¨ã®é–¢é€£ã‚’示ã™ä¸»ã‚ーをæŒã£ã¦ã„ã¾ã™ （実際ã€é–¢ä¿‚モデル上ã¯ä¸€å¯¾ä¸€é–¢é€£ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr "å¼åˆ¥åを用ã„㟠table-per-subclass"
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr "Hibernateã® table-per-subclass 実装ã¯ã€discriminatorカラムを必è¦ã¨ã—ãªã„ã“ã¨ã‚’覚ãˆã¦ãŠã„ã¦ãã ã•ã„。 Hibernate以外ã®O/Rマッパーã¯ã€table-per-subclass ã«ç•°ãªã‚‹å®Ÿè£…を用ã„ã¾ã™ã€‚ ãã‚Œã¯ã€ã‚¹ãƒ¼ãƒ‘ークラスã®ãƒ†ãƒ¼ãƒ–ルã«ã‚¿ã‚¤ãƒ—discriminatorカラムを必è¦ã¨ã—ã¾ã™ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯å®Ÿè£…ãŒå›°é›£ã«ãªã‚Šã¾ã™ãŒã€é–¢ä¿‚ã®è¦–点ã‹ã‚‰è¦‹ã‚‹ã¨ã€ã‚ˆã‚Šæ£ç¢ºãªã‚‚ã®ã§ã™ã€‚ table-per-subclass 戦略ã§discriminatorカラムを使ã„ãŸã‘ã‚Œã°ã€ <literal><subclass></literal> 㨠<literal><join></literal> を以下ã®ã‚ˆã†ã«çµ„ã¿åˆã‚ã›ã¦ä½¿ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:127
+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> 宣言ã¯ã€ スーパークラスã®ã‚¯ã‚¨ãƒªå®Ÿè¡Œæ™‚ã«å¤–部çµåˆã‚’使ã£ã¦ã€ サブクラス㮠<literal>ChequePayment</literal> データをå–å¾—ã—ãªã„よã†ã«æŒ‡å®šã™ã‚‹ãŸã‚ã®ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr "table-per-subclass 㨠table-per-class-hierarchy ã®æ··åˆ"
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr "ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’使用ã™ã‚‹ã¨ã€table-per-hierarchy 㨠table-per-subclass 戦略を 組ã¿åˆã‚ã›ã‚‹äº‹ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr "ã„ãšã‚Œã®ãƒžãƒƒãƒ”ング戦略ã§ã‚ã£ã¦ã‚‚ã€ãƒ«ãƒ¼ãƒˆã§ã‚ã‚‹ <literal>Payment</literal> クラスã¸ã® ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªé–¢é€£ã¯ <literal><many-to-one></literal> を使ã£ã¦ãƒžãƒƒãƒ”ングã—ã¾ã™ã€‚"
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr "<title>具象クラスã”ã¨ã®ãƒ†ãƒ¼ãƒ–ル（table-per-concrete-class）</title>"
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr "table-per-concrete-class 戦略ã®ãƒžãƒƒãƒ”ングã«å¯¾ã™ã‚‹ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€2ã¤ã‚ã‚Šã¾ã™ã€‚ 1ã¤ç›®ã¯ <literal><union-subclass></literal> を利用ã™ã‚‹æ–¹æ³•ã§ã™ã€‚"
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr "サブクラスã”ã¨ã«3ã¤ã®ãƒ†ãƒ¼ãƒ–ルãŒå¿…è¦ã§ã™ã€‚ãã‚Œãžã‚Œã®ãƒ†ãƒ¼ãƒ–ルã¯ã€ç¶™æ‰¿ãƒ—ãƒãƒ‘ティをå«ã‚“ã 〠クラスã®å…¨ã¦ã®ãƒ—ãƒãƒ‘ティã«å¯¾ã™ã‚‹ã‚«ãƒ©ãƒ を定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr "ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã«ã¯åˆ¶é™ãŒã‚ã‚Šã¾ã™ã€‚ ãã‚Œã¯ã€ãƒ—ãƒãƒ‘ティãŒã‚¹ãƒ¼ãƒ‘ークラスã«ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ãŸå ´åˆã€ å…¨ã¦ã®ã‚µãƒ–クラスã«ãŠã„ã¦ã‚«ãƒ©ãƒ åãŒåŒã˜ã§ãªã‘ã‚Œã°ãªã‚‰ãªã„ã¨ã„ã†ã‚‚ã®ã§ã™ã€‚ （Hibernateã®ä»Šå¾Œã®ãƒªãƒªãƒ¼ã‚¹ã§ç·©å’Œã•ã‚Œã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“）。 <union-subclass> を使ã£ãŸ table-per-concrete-class 戦略ã§ã¯è˜åˆ¥å生æˆæˆ¦ç•¥ã‚’使用ã§ãã¾ã›ã‚“。 主ã‚ーを生æˆã™ã‚‹ãŸã‚ã®ã‚·ãƒ¼ãƒ‰ã¯ã€å…¨ã¦ã® union subclass ã®éšŽå±¤å†…ã§å…±æœ‰ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (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> )。"
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr "暗黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を用ã„㟠table-per-concrete-class"
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr "ã‚‚ã†ä¸€ã¤ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯æš—黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã®ä½¿ç”¨ã§ã™ã€‚"
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr "<literal>Payment</literal> インターフェイスãŒã©ã“ã«ã‚‚明示的ã«ç¤ºã•ã‚Œã¦ã„ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ãã—ã¦ã€<literal>Payment</literal> プãƒãƒ‘ティãŒãã‚Œãžã‚Œã®ã‚µãƒ–クラスã«ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ã‚‹ã“ã¨ã«ã‚‚注æ„ã—ã¦ãã ã•ã„。 ã‚‚ã—é‡è¤‡ã‚’é¿ã‘ãŸã„ã®ã§ã‚ã‚Œã°ã€XMLエンティティã®åˆ©ç”¨ã‚’考ãˆã¦ãã ã•ã„。 （例： <literal>DOCTYPE</literal> 宣言ã«ãŠã‘ã‚‹ <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> ã¨ã€ãƒžãƒƒãƒ”ングã«ãŠã‘ã‚‹ <literal>&allproperties;</literal>）"
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr "ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã®æ¬ 点ã¯ã€HibernateãŒãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªã‚¯ã‚¨ãƒªã®å®Ÿè¡Œæ™‚ã«SQL <literal>UNION</literal> を生æˆã—ãªã„点ã§ã™ã€‚"
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr "ã“ã®ãƒžãƒƒãƒ”ング戦略ã«å¯¾ã—ã¦ã¯ã€<literal>Payment</literal> ã¸ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªé–¢é€£ã¯ 通常ã€<literal><any></literal> を使ã£ã¦ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr "ä»–ã®ç¶™æ‰¿ãƒžãƒƒãƒ”ングã¨æš—黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã®çµ„ã¿åˆã‚ã›"
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr "ã“ã®ãƒžãƒƒãƒ”ングã«ã¤ã„ã¦ã®æ›´ãªã‚‹æ³¨æ„点ãŒã‚ã‚Šã¾ã™ã€‚ サブクラスãŒè‡ªèº«ã‚’ <literal><class></literal> è¦ç´ ã¨ã—ã¦ãƒžãƒƒãƒ”ングã—ã¦ã„ã‚‹ã®ã§ã€ （ã‹ã¤ <literal>Payment</literal> ã¯å˜ãªã‚‹ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ãªã®ã§ï¼‰ã€ ãã‚Œãžã‚Œã®ã‚µãƒ–クラスã¯ç°¡å˜ã«ãã®ä»–ã®ç¶™æ‰¿éšŽå±¤ã®ä¸€éƒ¨ã¨ãªã‚Šã¾ã™ã€‚ （ã—ã‹ã‚‚ã€ä»Šã¾ã§ã©ãŠã‚Š <literal>Payment</literal> インターフェイスã«å¯¾ã™ã‚‹ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªã‚¯ã‚¨ãƒª を使用ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ï¼‰"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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> （ã¨CreditCardPaymentã®ã‚µãƒ–クラスã€<literal>Payment</literal> ã®å®Ÿè£…ã§ã‚ã‚‹ãŸã‚）〠ãŠã‚ˆã³ã€<literal>CashPayment</literal> ã€<literal>ChequePayment</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’è¿”ã—ã¾ã™ã€‚ <literal>NonelectronicTransaction</literal> インスタンスã¯è¿”ã—ã¾ã›ã‚“。"
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr "<title>制é™</title>"
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr "table-per-concrete-class マッピング戦略ã¸ã®ã€Œæš—黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã€ã‚¢ãƒ—ãƒãƒ¼ãƒã«ã¯ ã„ãã¤ã‹ã®åˆ¶é™ãŒã‚ã‚Šã¾ã™ã€‚<literal><union-subclass></literal> マッピングã«å¯¾ã—ã¦ã‚‚ å°‘ã—å¼±ã‚ã®åˆ¶é™ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr "次ã®ãƒ†ãƒ¼ãƒ–ルã«ã€Hibernateã«ãŠã‘ã‚‹table-per-concrete-classマッピング㮠制é™ã‚„暗黙的ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã®åˆ¶é™ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr "継承マッピングã®æ©Ÿèƒ½"
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr "継承戦略"
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr "多対一ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ "
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr "一対一ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ "
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr "一対多ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ "
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr "多対多ã®ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ "
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr "ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を使ã£ãŸ<literal>load()/get()</literal>"
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr "ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を使ã£ãŸã‚¯ã‚¨ãƒª"
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr "ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ を使ã£ãŸçµåˆ"
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr "外部çµåˆã«ã‚ˆã‚‹ãƒ•ã‚§ãƒƒãƒ"
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr "table per class-hierarchy"
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr "<many-to-one>"
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr "<one-to-one>"
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr "<one-to-many>"
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr "<many-to-many>"
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr "s.get(Payment.class, id)"
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr "from Payment p"
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr "from Order o join o.payment p"
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr "サãƒãƒ¼ãƒˆ"
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr "table per subclass"
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr "table per concrete-class (union-subclass)"
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr "table per concrete class (implicit polymorphism)"
+
+#: index.docbook:323
+msgid "<any>"
+msgstr "<any>"
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr "サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“"
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr "<many-to-any>"
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1348 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr "パフォーマンスã®æ”¹å–„"
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr "フェッãƒæˆ¦ç•¥"
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr "<emphasis>フェッãƒæˆ¦ç•¥</emphasis> ã¯ã€ã‚¢ãƒ—リケーションãŒé–¢é€£ã‚’ナビゲートã™ã‚‹å¿…è¦ãŒã‚ã‚‹ ã¨ãã«ã€HibernateãŒé–¢é€£ã‚ªãƒ–ジェクトを復元ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã™ã‚‹æˆ¦ç•¥ã§ã™ã€‚フェッãƒæˆ¦ç•¥ã¯O/Rマッピング㮠メタデータã«å®£è¨€ã™ã‚‹ã‹ã€ç‰¹å®šã®HQL〠<literal>Criteria</literal> クエリã§ã‚ªãƒ¼ãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr "Hibernate3ã¯æ¬¡ã«ç¤ºã™ãƒ•ã‚§ãƒƒãƒæˆ¦ç•¥ã‚’定義ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr "<emphasis>çµåˆãƒ•ã‚§ãƒƒãƒ</emphasis> - Hibernate㯠<literal>OUTER JOIN</literal> を使ã£ã¦ã€ 関連ã™ã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚„コレクションを１ã¤ã® <literal>SELECT</literal> ã§å¾©å…ƒã—ã¾ã™ã€‚"
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>セレクトフェッãƒ</emphasis> - 2回目㮠<literal>SELECT</literal> ã§é–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„コレクションを復元ã—ã¾ã™ã€‚ <literal>lazy=\"false\"</literal> ã§æ˜Žç¤ºçš„ã«é…延フェッãƒã‚’無効ã«ã—ãªã‘ã‚Œã°ã€ã“ã®2回目ã®selectã¯å®Ÿéš›ã« 関連ã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã¨ãã®ã¿å®Ÿè¡Œã•ã‚Œã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>サブセレクトフェッãƒ</emphasis> - 2回目㮠<literal>SELECT</literal> ã§ã€ç›´å‰ã®ã‚¯ã‚¨ãƒªã‚„フェッãƒã§å¾©å…ƒã—ãŸã™ã¹ã¦ã®è¦ç´ ã«é–¢é€£ã™ã‚‹ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ 復元ã—ã¾ã™ã€‚ <literal>lazy=\"false\"</literal> ã§æ˜Žç¤ºçš„ã«é…延フェッãƒã‚’無効ã«ã—ãªã‘ã‚Œã°ã€ã“ã®2回目ã®selectã¯å®Ÿéš›ã« 関連ã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã¨ãã®ã¿å®Ÿè¡Œã•ã‚Œã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr "<emphasis>ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒ</emphasis> - セレクトフェッãƒã®ãŸã‚ã®æœ€é©åŒ–ã•ã‚ŒãŸæˆ¦ç•¥ - Hibernateã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚„コレクションã®ä¸€ç¾¤ã‚’1回㮠<literal>SELECT</literal> ã§å¾©å…ƒã—ã¾ã™ã€‚ã“ã‚Œã¯ä¸»ã‚ーや外部ã‚ーã®ãƒªã‚¹ãƒˆã‚’指定ã™ã‚‹ã“ã¨ã« ã«ã‚ˆã‚Šè¡Œã„ã¾ã™ã€‚"
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr "Hibernateã¯æ¬¡ã«ç¤ºã™æˆ¦ç•¥ã¨ã‚‚区別をã—ã¾ã™ã€‚"
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr "<emphasis>å³æ™‚フェッãƒ</emphasis> - 所有者ã®ã‚ªãƒ–ジェクトãŒãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã¨ãã«ã€ 関連ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯å³æ™‚ã«ãƒ•ã‚§ãƒƒãƒã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr "<emphasis>é…延コレクションフェッãƒ</emphasis> - アプリケーションãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã« 対ã—ã¦æ“作を行ã£ãŸã¨ãã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’フェッãƒã—ã¾ã™ã€‚ (ã“ã‚Œã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã™ã‚‹ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®å‹•ä½œã§ã™)"
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr "<emphasis>\"特別ãªé…延\"コレクションフェッãƒ</emphasis> - コレクションã®è¦ç´ １ã¤ï¼‘ã¤ãŒç‹¬ç«‹ã—ã¦ã€å¿…è¦ãªã¨ãã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰å–å¾—ã•ã‚Œã¾ã™ã€‚ Hibernateã¯å¿…è¦ãªã„ãªã‚‰ã°ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³å…¨ä½“をメモリã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã“ã¨ã¯ é¿ã‘ã¾ã™ï¼ˆã¨ã¦ã‚‚大ããªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«é©ã—ã¦ã„ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr "<emphasis>プãƒã‚シフェッãƒ</emphasis> - å˜ä¸€å€¤é–¢é€£ã¯ã€è˜åˆ¥åã®getter以外㮠メソッドãŒé–¢é€£ã‚ªãƒ–ジェクトã§å‘¼ã³å‡ºã•ã‚Œã‚‹ã¨ãã«ãƒ•ã‚§ãƒƒãƒã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>\"プãƒã‚ã‚·ãªã—\"フェッãƒ</emphasis> - å˜ä¸€å€¤é–¢é€£ã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ã« アクセスã•ã‚ŒãŸã¨ãã«ãƒ•ã‚§ãƒƒãƒã•ã‚Œã¾ã™ã€‚プãƒã‚シフェッãƒã¨æ¯”較ã™ã‚‹ã¨ã€ã“ã®æ–¹æ³•ã¯ é…延ã®åº¦åˆã„ãŒå°‘ãªã„（関連ã¯è˜åˆ¥åã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãŸã ã‘ã§ã‚‚フェッãƒã•ã‚Œã¾ã™ï¼‰ ã§ã™ãŒã€ã‚ˆã‚Šé€éŽçš„ã§ã€ã‚¢ãƒ—リケーションã«ãƒ—ãƒã‚ã‚·ãŒå˜åœ¨ã—ãªã„よã†ã«è¦‹ã›ã¾ã™ã€‚ ã“ã®æ–¹æ³•ã¯ãƒ“ルド時ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ãŒå¿…è¦ã«ãªã‚Šã€ä½¿ã†å ´é¢ã¯ã¾ã‚Œã§ã™ã€‚"
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>é…延属性フェッãƒ</emphasis> - 属性やå˜ä¸€å€¤é–¢é€£ã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ã«ã‚¢ã‚¯ã‚»ã‚¹ã—㟠ã¨ãã«ãƒ•ã‚§ãƒƒãƒã•ã‚Œã¾ã™ã€‚ã“ã®æ–¹æ³•ã¯ãƒ“ルド時ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ãŒå¿…è¦ã«ãªã‚Šã€ 使ã†å ´é¢ã¯ã¾ã‚Œã§ã™ã€‚"
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr "二ã¤ã®ç›´è¡Œã™ã‚‹æ¦‚念ãŒã‚ã‚Šã¾ã™: <emphasis>ã„ã¤</emphasis> 関連をフェッãƒã™ã‚‹ã‹ã€ ãã—ã¦ã€ <emphasis>ã©ã†ã‚„ã£ã¦</emphasis> フェッãƒã™ã‚‹ã‹ï¼ˆã©ã‚“ãªSQLを使ã£ã¦ï¼‰ã€‚ ã“れらを混åŒã—ãªã„ã§ãã ã•ã„ï¼ <literal>fetch</literal> ã¯ãƒ‘フォーマンスãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã«ä½¿ã„ã¾ã™ã€‚ <literal>lazy</literal> ã¯ã‚るクラスã®åˆ†é›¢ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ã†ã¡ã€ã©ã®ãƒ‡ãƒ¼ã‚¿ã‚’常㫠使用å¯èƒ½ã«ã™ã‚‹ã‹ã®å–り決ã‚を定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr "é…延関連ã®åƒã"
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr "デフォルトã§ã¯ã€Hibernate3ã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã—ã¦ã¯é…延セレクトフェッãƒã‚’使ã„〠å˜ä¸€å€¤é–¢é€£ã«ã¯é…延プãƒã‚シフェッãƒã‚’使ã„ã¾ã™ã€‚ã“れらã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå‹•ä½œã¯ã»ã¼ã™ã¹ã¦ã® アプリケーションã®ã»ã¼ã™ã¹ã¦ã®é–¢é€£ã§æ„味ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr "<emphasis>注:</emphasis> <literal>hibernate.default_batch_fetch_size</literal> をセットã—ãŸã¨ãã¯ã€Hibernate㯠é…延フェッãƒã®ãŸã‚ã®ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒæœ€é©åŒ–を使ã†ã§ã—ょㆠ（ã“ã®æœ€é©åŒ–ã¯ã‚ˆã‚Šç´°ã‹ã„レベルã§æœ‰åŠ¹ã«ã™ã‚‹ã“ã¨ã‚‚出æ¥ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr "ã—ã‹ã—ã€é…延フェッãƒã¯çŸ¥ã£ã¦ãŠã‹ãªã‘ã‚Œã°ãªã‚‰ãªã„一ã¤ã®å•é¡ŒãŒã‚ã‚Šã¾ã™ã€‚ Hibernateã®sessionをオープンã—ã¦ã„るコンテã‚ストã®å¤–ã‹ã‚‰é…延関連ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã¨ã€ 例外ãŒç™ºç”Ÿã—ã¾ã™ã€‚例："
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr ""
+ "<![CDATA[s = sessions.openSession();
+\n"
+ "Transaction tx = s.beginTransaction();
+\n"
+ "
+\n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")
+\n"
+ " .setString(\"userName\", userName).uniqueResult();
+\n"
+ "Map permissions = u.getPermissions();
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "s.close();
+\n"
+ "
+\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr "<literal>Session</literal> ãŒã‚¯ãƒãƒ¼ã‚ºã•ã‚ŒãŸã¨ãã€permissionsコレクション㯠åˆæœŸåŒ–ã•ã‚Œã¦ã„ãªã„ãŸã‚ã€ã“ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯è‡ªèº«ã®çŠ¶æ…‹ã‚’ãƒãƒ¼ãƒ‰ã§ãã¾ã›ã‚“。 <emphasis>Hibernateã¯åˆ‡ã‚Šé›¢ã•ã‚ŒãŸã‚ªãƒ–ジェクトã®é…延åˆæœŸåŒ–ã¯ã‚µãƒãƒ¼ãƒˆ ã—ã¦ã„ã¾ã›ã‚“</emphasis> 。修æ£æ–¹æ³•ã¨ã—ã¦ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‹ã‚‰èªã¿è¾¼ã¿ã‚’è¡Œã†ã‚³ãƒ¼ãƒ‰ã‚’ トランザクションをコミットã™ã‚‹ç›´å‰ã«ç§»å‹•ã•ã›ã¾ã™ã€‚"
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr "一方ã§ã€ <literal>lazy=\"false\"</literal> を関連マッピングã«æŒ‡å®šã™ã‚‹ã“ã¨ã§ã€ é…延処ç†ã‚’ã—ãªã„コレクションや関連を使ã†ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ ã—ã‹ã—ãªãŒã‚‰ã€é…延åˆæœŸåŒ–ã¯ã»ã¼ã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚„関連ã§ä½¿ã‚れるã“ã¨ã‚’ æ„図ã—ã¦ã„ã¾ã™ã€‚ã‚‚ã—ã‚ãªãŸã®ã‚ªãƒ–ジェクトモデルã®ä¸ã«é…延処ç†ã‚’ã—ãªã„関連を 多ã定義ã—ã¦ã—ã¾ã†ã¨ã€Hibernateã¯æœ€çµ‚çš„ã«ã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³æ¯Žã« ã»ã¼å®Œå…¨ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’メモリã®ä¸ã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã“ã¨ã«ãªã‚‹ã§ã—ょã†ï¼"
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr "ä»–æ–¹ã§ã¯ã€ç‰¹å®šã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«ãŠã„ã¦ã‚»ãƒ¬ã‚¯ãƒˆãƒ•ã‚§ãƒƒãƒã®ä»£ã‚ã‚Šã« çµåˆãƒ•ã‚§ãƒƒãƒï¼ˆå½“然ã“ã‚Œã¯é…延処ç†ã§ã¯ãªããªã‚Šã¾ã™ï¼‰ã‚’é¸æŠžã—ãŸã„ã“ã¨ãŒ 時々ã‚ã‚Šã¾ã™ã€‚ã“ã‚Œã‹ã‚‰ãƒ•ã‚§ãƒƒãƒæˆ¦ç•¥ã‚’カスタマイズã™ã‚‹æ–¹æ³•ã‚’ãŠè¦‹ã›ã—ã¾ã™ã€‚ Hibernate3ã§ã¯ã€ãƒ•ã‚§ãƒƒãƒæˆ¦ç•¥ã‚’é¸æŠžã™ã‚‹ä»•çµ„ã¿ã¯å˜ä¸€å€¤é–¢é€£ã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã§ 変ã‚ã‚Šã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr "フェッãƒæˆ¦ç•¥ã®ãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°"
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr "セレクトフェッãƒï¼ˆãƒ‡ãƒ•ã‚©ãƒ«ãƒˆï¼‰ã¯N+1セレクトå•é¡Œã¨ã„ã†å¤§ããªå¼±ç‚¹ãŒã‚ã‚‹ãŸã‚〠マッピング定義ã§çµåˆãƒ•ã‚§ãƒƒãƒã‚’有効ã«ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr ""
+ "<![CDATA[<set name=\"permissions\"
+\n"
+ " fetch=\"join\">
+\n"
+ " <key column=\"userId\"/>
+\n"
+ " <one-to-many class=\"Permission\"/>
+\n"
+ "</set]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr "マッピング定義ã§å®šç¾©ã—㟠<literal>フェッãƒ</literal> 戦略ã¯æ¬¡ã®ã‚‚ã®ã«å½±éŸ¿ã—ã¾ã™ã€‚"
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr "<literal>get()</literal> ã‚„ <literal>load()</literal> ã«ã‚ˆã‚‹å¾©å…ƒ"
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr "関連ã«ãƒŠãƒ“ゲートã—ãŸã¨ãã«ç™ºç”Ÿã™ã‚‹æš—黙的ãªå¾©å…ƒ"
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr "<literal>Criteria</literal> クエリ"
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr "<literal>サブセレクト</literal> フェッãƒã‚’使ã†HQLクエリ"
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr "ãŸã¨ãˆã©ã‚“ãªãƒ•ã‚§ãƒƒãƒæˆ¦ç•¥ã‚’使ã£ãŸã¨ã—ã¦ã‚‚ã€é…延ã§ã¯ãªã„グラフã¯ãƒ¡ãƒ¢ãƒªã«èªã¿è¾¼ã¾ã‚Œã‚‹ã“ã¨ãŒ ä¿è¨¼ã•ã‚Œã¾ã™ã€‚ã¤ã¾ã‚Šã€ç‰¹å®šã®HQLクエリを実行ã™ã‚‹ãŸã‚ã«ã„ãã¤ã‹ã®SELECTæ–‡ãŒå³æ™‚実行ã•ã‚Œã‚‹ ã“ã¨ãŒã‚ã‚‹ã®ã§æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr "通常ã¯ã€ãƒžãƒƒãƒ”ング定義ã§ãƒ•ã‚§ãƒƒãƒã®ã‚«ã‚¹ã‚¿ãƒžã‚¤ã‚ºã¯è¡Œã„ã¾ã›ã‚“。 代ã‚ã‚Šã«ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®å‹•ä½œã®ã¾ã¾ã«ã—ã¦ãŠã„ã¦ã€HQL㧠<literal>left join fetch</literal> ã‚’ 指定ã™ã‚‹ã“ã¨ã§ç‰¹å®šã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã§å‹•ä½œã‚’オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™ã€‚ ã“ã‚Œã¯Hibernateã«åˆå›žã®ã‚»ãƒ¬ã‚¯ãƒˆã§å¤–部çµåˆã‚’使ã£ã¦é–¢é€£ã‚’å…ˆã«ãƒ•ã‚§ãƒƒãƒã™ã‚‹ã‚ˆã†ã«æŒ‡å®šã—ã¦ã„ã¾ã™ã€‚ <literal>Criteria</literal> クエリã®APIã§ã¯ã€ <literal>setFetchMode(FetchMode.JOIN)</literal> を使ã†ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr "ã‚‚ã— <literal>get()</literal> ã‚„ <literal>load()</literal> ã§ä½¿ã‚れる フェッãƒæˆ¦ç•¥ã‚’変ãˆãŸã„ã¨æ„Ÿã˜ãŸã¨ãã«ã¯ã€å˜ç´”ã« <literal>Criteria</literal> クエリを使ã£ã¦ãã ã•ã„。例："
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)
+\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)
+\n"
+ " .add( Restrictions.idEq(userId) )
+\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr "（ã“ã‚Œã¯ã„ãã¤ã‹ã®ORMソリューションãŒ\"fetch plan\"ã¨å‘¼ã‚“ã§ã„ã‚‹ã‚‚ã®ã¨åŒã˜ã§ã™ã€‚）"
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr "N+1セレクトå•é¡Œã‚’é¿ã‘ã‚‹ãŸã‚ã®ã¾ã£ãŸãé•ã†æ–¹æ³•ã¯ã€ç¬¬2レベルã‚ャッシュを使ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr "å˜ä¸€ç«¯é–¢é€£ãƒ—ãƒã‚ã‚·"
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr "コレクションã®é…延フェッãƒã¯ã€Hibernate自身ã®å®Ÿè£…ã«ã‚ˆã‚‹æ°¸ç¶šã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã£ã¦ 実ç¾ã—ã¦ã„ã¾ã™ã€‚ã—ã‹ã—ã€å˜ä¸€ç«¯é–¢é€£ã«ãŠã‘ã‚‹é…延処ç†ã§ã¯ã€é•ã†ä»•çµ„ã¿ãŒ å¿…è¦ã§ã™ã€‚対象ã®é–¢é€£ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¯ãƒ—ãƒã‚ã‚·ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。Hibernate㯠（ã™ã°ã‚‰ã—ã„CGLIBライブラリã«ã‚ˆã‚‹ï¼‰å®Ÿè¡Œæ™‚ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰æ‹¡å¼µã‚’ 使ã£ã¦æ°¸ç¶šã‚ªãƒ–ジェクトã®é…延åˆæœŸåŒ–プãƒã‚シを実ç¾ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr "デフォルトã§ã¯ã€Hibernate3ã¯ï¼ˆé–‹å§‹æ™‚ã«ï¼‰ã™ã¹ã¦ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒã‚シを生æˆã—〠ãれらを使ã£ã¦ã€ <literal>many-to-one</literal> ã‚„ <literal>one-to-one</literal> 関連㮠é…延フェッãƒã‚’å¯èƒ½ã«ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr "マッピングファイル㧠<literal>proxy</literal> 属性ã«ã‚ˆã£ã¦ã€ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒã‚シインターフェイスã¨ã—㦠使ã†ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’宣言ã§ãã¾ã™ã€‚デフォルトã§ã¯ã€Hibernateã¯ãã®ã‚¯ãƒ©ã‚¹ã®ã‚µãƒ–クラスを使ã„ã¾ã™ã€‚ <emphasis>プãƒã‚シクラスã¯å°‘ãªãã¨ã‚‚パッケージå¯è¦–ã§ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ã‚’実装ã—ãªã‘れ㰠ãªã‚‰ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。ã™ã¹ã¦ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã«ã“ã®ã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ã‚’推奨ã—ã¾ã™ï¼</emphasis>"
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr "ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã®ã‚¯ãƒ©ã‚¹ã«å¯¾ã—ã¦ã“ã®æ–¹æ³•ã‚’é©ç”¨ã™ã‚‹ã¨ãã«ã„ãã¤ã‹è€ƒæ…®ã™ã‚‹ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ 例："
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">
+\n"
+ " ......
+\n"
+ " <subclass name=\"DomesticCat\">
+\n"
+ " .....
+\n"
+ " </subclass>
+\n"
+ "</class>]]>"
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr "第一ã«ã€ <literal>Cat</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ <literal>DomesticCat</literal> ã«ã‚ャストã§ãã¾ã›ã‚“。ãŸã¨ãˆåŸºã¨ãªã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒ <literal>DomesticCat</literal> ã§ã‚ã£ãŸã¨ã—ã¦ã‚‚ã§ã™ã€‚"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)
+\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy
+\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!
+\n"
+ " ....
+\n"
+ "}]]>"
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr "第二ã«ã€ãƒ—ãƒã‚ã‚·ã® <literal>==</literal> ã¯æˆç«‹ã—ãªã„ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy
+\n"
+ "DomesticCat dc =
+\n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!
+\n"
+ "System.out.println(cat==dc); // false]]>"
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr "ã—ã‹ã—ã€ã“ã‚Œã¯è¦‹ã‹ã‘ã»ã©æ‚ªã„状æ³ã¨ã„ã†ã‚ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。ãŸã¨ãˆç•°ãªã£ãŸãƒ—ãƒã‚シオブジェクトã¸ã® 二ã¤ã®å‚ç…§ãŒã‚ã£ãŸã¨ã—ã¦ã‚‚ã€åŸºã¨ãªã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯åŒã˜ã‚ªãƒ–ジェクトã§ã™ã€‚"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy
+\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr "第三ã«ã€ <literal>final</literal> クラスや <literal>final</literal> メソッドをæŒã¤ã‚¯ãƒ©ã‚¹ã« CGLIBプãƒã‚シを使ãˆã¾ã›ã‚“。"
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr "最後ã«ã€ã‚‚ã—永続オブジェクトã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹åŒ–時(例ãˆã°ã€åˆæœŸåŒ–処ç†ã‚„デフォルトコンストラクタã®ä¸ã§) ã«ãªã‚“らã‹ã®ãƒªã‚½ãƒ¼ã‚¹ãŒå¿…è¦ã¨ãªã‚‹ãªã‚‰ã€ãã®ãƒªã‚½ãƒ¼ã‚¹ã‚‚ã¾ãŸãƒ—ãƒã‚シを通ã—ã¦å–å¾—ã•ã‚Œã¾ã™ã€‚ 実際ã«ã¯ã€ãƒ—ãƒã‚シクラスã¯æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ã‚µãƒ–クラスã§ã™ã€‚"
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr "ã“れらã®å•é¡Œã¯Javaã®å˜ä¸€ç¶™æ‰¿ãƒ¢ãƒ‡ãƒ«ã®åŽŸç†ä¸Šã®åˆ¶é™ã®ãŸã‚ã§ã™ã€‚ã‚‚ã—ã“れらã®å•é¡Œã‚’é¿ã‘ãŸã„ã®ãªã‚‰ã€ ビジãƒã‚¹ãƒ¡ã‚½ãƒƒãƒ‰ã‚’宣言ã—ãŸã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’ãã‚Œãžã‚Œæ°¸ç¶šã‚¯ãƒ©ã‚¹ã§å®Ÿè£…ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 マッピングファイルã§ã“れらã®ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’指定ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚例："
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">
+\n"
+ " ......
+\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">
+\n"
+ " .....
+\n"
+ " </subclass>
+\n"
+ "</class>]]>"
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr "<literal>CatImpl</literal> 㯠<literal>Cat</literal> インターフェイスを実装ã™ã‚‹ã®ã«å¯¾ã—〠<literal>DomesticCatImpl</literal> 㯠<literal>DomesticCat</literal> を実装ã—ã¾ã™ã€‚ ã™ã‚‹ã¨ã€ <literal>load()</literal> ã‚„ <literal>iterate()</literal> ã¯ã€ <literal>Cat</literal> ã‚„ <literal>DomesticCat</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒ—ãƒã‚ã‚·ã‚’ è¿”ã—ã¾ã™ã€‚（ <literal>list()</literal> ã¯é€šå¸¸ã¯ãƒ—ãƒã‚ã‚·ã‚’è¿”ã•ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。）"
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);
+\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();
+\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr "関連もé…延åˆæœŸåŒ–ã•ã‚Œã¾ã™ã€‚ã“ã‚Œã¯ãƒ—ãƒãƒ‘ティを <literal>Cat</literal> åž‹ã§å®£è¨€ã—ãªã‘れ㰠ãªã‚‰ãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚ <literal>CatImpl</literal> ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr "プãƒã‚ã‚·ã®åˆæœŸåŒ–ã‚’ <emphasis>å¿…è¦ã¨ã—ãªã„</emphasis> æ“作もå˜åœ¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr "<literal>equals()</literal> （永続クラス㌠<literal>equals()</literal> ã‚’ オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ãªã„ã¨ã）"
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr "<literal>hashCode()</literal> （永続クラス㌠<literal>hashCode()</literal> ã‚’ オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ãªã„ã¨ã）"
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr "è˜åˆ¥åã®getterメソッド"
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr "Hibernate㯠<literal>equals()</literal> ã‚„ <literal>hashCode()</literal> をオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—㟠永続クラスを検出ã—ã¾ã™ã€‚"
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr "デフォルト㮠<literal>lazy=\"proxy\"</literal> ã®ä»£ã‚ã‚Šã«ã€ <literal>lazy=\"no-proxy\"</literal> ã‚’ é¸ã‚“ã ã“ã¨ã§ã€åž‹å¤‰æ›ã«é–¢é€£ã™ã‚‹å•é¡Œã‚’回é¿ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ ã—ã‹ã—ã€ãƒ“ルド時ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ãŒå¿…è¦ã«ãªã‚Šã€ã©ã®ã‚ˆã†ãªæ“作ã§ã‚ã£ã¦ã‚‚〠ãŸã ã¡ã«ãƒ—ãƒã‚ã‚·ã®åˆæœŸåŒ–ã‚’è¡Œã†ã“ã¨ã«ãªã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr "コレクションã¨ãƒ—ãƒã‚ã‚·ã®åˆæœŸåŒ–"
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr "<literal>LazyInitializationException</literal> ã¯ã€ <literal>Session</literal> ã®ã‚¹ã‚³ãƒ¼ãƒ—外ã‹ã‚‰ åˆæœŸåŒ–ã—ã¦ã„ãªã„コレクションやプãƒã‚ã‚·ã«ã‚¢ã‚¯ã‚»ã‚¹ã•ã‚ŒãŸã¨ãã«ã€Hibernateã«ã‚ˆã£ã¦ã‚¹ãƒãƒ¼ã•ã‚Œã¾ã™ã€‚ ã™ãªã‚ã¡ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚„プãƒã‚ã‚·ã¸ã®å‚照をæŒã¤ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒåˆ†é›¢ã•ã‚ŒãŸçŠ¶æ…‹ã®æ™‚ã§ã™ã€‚"
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr "<literal>Session</literal> をクãƒãƒ¼ã‚ºã™ã‚‹å‰ã«ãƒ—ãƒã‚シやコレクションã®åˆæœŸåŒ–を確実㫠行ã„ãŸã„ã¨ããŒã‚ã‚Šã¾ã™ã€‚ã‚‚ã¡ã‚ん〠<literal>cat.getSex()</literal> ã‚„ <literal>cat.getKittens().size()</literal> ãªã©ã‚’常ã«å‘¼ã³å‡ºã™ã“ã¨ã§åˆæœŸåŒ–を強制ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã™ã€‚ ã—ã‹ã—ã“ã‚Œã¯ã‚³ãƒ¼ãƒ‰ã‚’èªã‚€äººã‚’æ··ä¹±ã•ã›ã€æ±Žç”¨çš„ãªã‚³ãƒ¼ãƒ‰ã¨ã„ã†ç‚¹ã‹ã‚‰ã‚‚ä¸ä¾¿ã§ã™ã€‚"
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr "staticメソッド㮠<literal>Hibernate.initialize()</literal> ã‚„ <literal>Hibernate.isInitialized()</literal> ã¯é…延åˆæœŸåŒ–ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚„プãƒã‚シを扱ã†ã¨ãã«ä¾¿åˆ©ãªæ–¹æ³•ã‚’アプリケーションã«æä¾›ã—ã¾ã™ã€‚ <literal>Hibernate.initialize(cat)</literal> ã¯ã€ <literal>Session</literal> ãŒã‚ªãƒ¼ãƒ—ンã—ã¦ã„ã‚‹é™ã‚Šã¯ <literal>cat</literal> プãƒã‚シを強制的ã«åˆæœŸåŒ–ã—ã¾ã™ã€‚ <literal>Hibernate.initialize( cat.getKittens() )</literal> ã¯kittensコレクションã«å¯¾ã—ã¦åŒæ§˜ã® 効果ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr "別ã®é¸æŠžè‚¢ã¨ã—ã¦ã€å¿…è¦ãªã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚„プãƒã‚ã‚·ãŒãƒãƒ¼ãƒ‰ã•ã‚Œã‚‹ã¾ã§ <literal>Session</literal> をオープンã«ã—ã¦ãŠã方法ãŒã‚ã‚Šã¾ã™ã€‚ã„ãã¤ã‹ã®ã‚¢ãƒ—リケーション㮠アーã‚テクãƒãƒ£ã§ã¯ã€ç‰¹ã«Hibernateã«ã‚ˆã‚‹ãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹ã‚’è¡Œã†ã‚³ãƒ¼ãƒ‰ã¨ã€ãれを使ㆠコードãŒç•°ãªã‚‹ã‚¢ãƒ—リケーションã®ãƒ¬ã‚¤ãƒ¤ãƒ¼ã‚„ã€ç‰©ç†çš„ã«ç•°ãªã‚‹ãƒ—ãƒã‚»ãƒƒã‚µã®ã¨ãã«ã¯ã€ コレクションãŒåˆæœŸåŒ–ã•ã‚Œã‚‹ã¨ãã« <literal>Session</literal> ãŒã‚ªãƒ¼ãƒ—ンã—ã¦ã„ã‚‹ã“ã¨ã‚’ ä¿è¨¼ã™ã‚‹å•é¡ŒãŒã‚ã‚Šã¾ã™ã€‚ã“ã®å•é¡Œã«å¯¾ã—ã¦ã¯2ã¤ã®åŸºæœ¬çš„ãªæ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr "Webベースã®ã‚¢ãƒ—リケーションã§ã¯ã€ ビューã®ãƒ¬ãƒ³ãƒ€ãƒªãƒ³ã‚°ãŒå®Œäº†ã—ã€ãƒªã‚¯ã‚¨ã‚¹ãƒˆãŒçµ‚ã‚る一番最後㧠<literal>Session</literal> をクãƒãƒ¼ã‚ºã™ã‚‹ãŸã‚ã«ã€ã‚µãƒ¼ãƒ–レットフィルタを使ã†ã“ã¨ãŒã§ãã¾ã™ï¼ˆ <emphasis>Open Session in View</emphasis> パターンã§ã™ï¼‰ã€‚ã‚‚ã¡ã‚ã‚“ã€ã‚¢ãƒ—リケーション基盤ã®ä¾‹å¤–処ç†ã®æ£ç¢ºæ€§ãŒéžå¸¸ã«é‡è¦ã«ãªã‚Šã¾ã™ã€‚ ビューã®ãƒ¬ãƒ³ãƒ€ãƒªãƒ³ã‚°ä¸ã«ä¾‹å¤–ãŒç™ºç”Ÿã—ãŸã¨ãã§ã•ãˆã€ãƒ¦ãƒ¼ã‚¶ã«å‡¦ç†ãŒæˆ»ã‚‹å‰ã« <literal>Session</literal> ã®ã‚¯ãƒãƒ¼ã‚ºã¨ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®çµ‚了を行ㆠã“ã¨ãŒä¸å¯æ¬ ã«ãªã‚Šã¾ã™ã€‚ Hibernateã®Wikiã«è¼‰ã£ã¦ã„ã‚‹\"Open Session in View\"パターンã®ä¾‹ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr "ビジãƒã‚¹å±¤ãŒåˆ†é›¢ã—ã¦ã„るアプリケーションã§ã¯ã€ãƒ“ジãƒã‚¹ãƒã‚¸ãƒƒã‚¯ã¯ Web層ã§å¿…è¦ã«ãªã‚‹ã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’事å‰ã«\"準備\"ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ç‰¹å®šã®ãƒ¦ãƒ¼ã‚¹ã‚±ãƒ¼ã‚¹ã§å¿…è¦ã¨ãªã‚‹ãƒ—レゼンテーション/Web層ã«å¯¾ã—〠ビジãƒã‚¹å±¤ãŒã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ã‚’ãƒãƒ¼ãƒ‰ã—ã€ã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ã‚’åˆæœŸåŒ–ã—ã¦è¿”ã™ã¹ã㨠ã„ã†ã“ã¨ã‚’æ„味ã—ã¦ã„ã¾ã™ã€‚通常ã¯ã€ã‚¢ãƒ—リケーションã¯Web層ã§å¿…è¦ãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ ãã‚Œãžã‚Œã«å¯¾ã—㦠<literal>Hibernate.initialize()</literal> を呼ã³å‡ºã™ã‹ （ã“ã®å‘¼ã³å‡ºã—ã¯ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚’クãƒãƒ¼ã‚ºã™ã‚‹å‰ã«è¡Œã†å¿…è¦ãŒã‚ã‚Šã¾ã™ï¼‰ã€ Hibernateクエリ㮠<literal>FETCH</literal> 節や <literal>Criteria</literal> ã® <literal>FetchMode.JOIN</literal> を使ã£ã¦ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’å…ˆã«å¾©å…ƒã—ã¾ã™ã€‚ 普通㯠<emphasis>Session Facade</emphasis> パターンã®ä»£ã‚ã‚Šã« <emphasis>!
Command</emphasis> パターンを採用ã™ã‚‹ã»ã†ãŒã‚ˆã‚Šç°¡å˜ã§ã™ã€‚"
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr "åˆæœŸåŒ–ã•ã‚Œã¦ã„ãªã„コレクション（もã—ãã¯ä»–ã®ãƒ—ãƒã‚シ）ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹å‰ã«ã€ <literal>merge()</literal> ã‚„ <literal>lock()</literal> を使ã£ã¦æ–°ã—ã„ <literal>Session</literal> ã«ä»¥å‰ã«ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã‚ªãƒ–ã‚¸ã‚§ã‚¯ãƒˆã‚’è¿½åŠ ã™ã‚‹ã“ã¨ã‚‚出æ¥ã¾ã™ã€‚ アドホックãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã‚’å°Žå…¥ã—ãŸã®ã§ã€Hibernate㯠ã“れを自動的ã«è¡Œã‚ãšã€ <emphasis>è¡Œã†ã¹ãã§ã‚‚ã‚ã‚Šã¾ã›ã‚“</emphasis> ï¼"
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr "大ããªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’åˆæœŸåŒ–ã—ãŸãã¯ãªã„ãŒã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã¤ã„ã¦ã®ãªã‚“らã‹ã®æƒ…å ±ï¼ˆã‚µã‚¤ã‚ºã®ã‚ˆã†ãªï¼‰ やデータã®ã‚µãƒ–セットを必è¦ã¨ã™ã‚‹ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr "コレクションフィルタを使ã†ã“ã¨ã§ã€åˆæœŸåŒ–ã›ãšã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚µã‚¤ã‚ºã‚’å–å¾—ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr "<literal>createFilter()</literal> メソッドã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³å…¨ä½“ã‚’åˆæœŸåŒ–ã™ã‚‹å¿…è¦ãªã—ã«ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã® サブセットを復元ã™ã‚‹ãŸã‚ã«åŠ¹æžœçš„ã«ä½¿ãˆã¾ã™ã€‚"
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr "ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã®ä½¿ç”¨"
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr "Hibernateã¯ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã‚’効率的ã«ä½¿ç”¨ã§ãã¾ã™ã€‚一ã¤ã®ãƒ—ãƒã‚シ（もã—ãã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼‰ãŒã‚¢ã‚¯ã‚»ã‚¹ ã•ã‚Œã‚‹ã¨ã€Hibernateã¯ã„ãã¤ã‹ã®åˆæœŸåŒ–ã—ã¦ã„ãªã„プãƒã‚ã‚·ã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã¯ é…延セレクトフェッãƒæˆ¦ç•¥ã«å¯¾ã™ã‚‹æœ€é©åŒ–ã§ã™ã€‚ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã®èª¿æ•´ã«ã¯ï¼’ã¤ã®æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚ クラスレベルã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒ¬ãƒ™ãƒ«ã§ã™ã€‚"
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr "クラスã€è¦ç´ ã®ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã¯ç†è§£ãŒç°¡å˜ã§ã™ã€‚実行時ã®æ¬¡ã®å ´é¢ã‚’想åƒã—ã¦ãã ã•ã„。 <literal>Session</literal> ã«ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸ25個㮠<literal>Cat</literal> インスタンスãŒå˜åœ¨ã—〠ãã‚Œãžã‚Œã® <literal>Cat</literal> 㯠<literal>owner</literal> ã§ã‚ã‚‹ <literal>Person</literal> ã¸ã®é–¢é€£ã‚’æŒã¡ã¾ã™ã€‚ <literal>Person</literal> クラス㯠<literal>lazy=\"true\"</literal> ã®ãƒ—ãƒã‚ã‚·ã§ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ã¾ã™ã€‚ ã‚‚ã—今ã™ã¹ã¦ã®Catã«å¯¾ã—ã¦ç¹°ã‚Šè¿”ã— <literal>getOwner()</literal> を呼ã³å‡ºã™ã¨ã€Hibernate㯠デフォルトã§ã¯25回㮠<literal>SELECT</literal> を実行ã—ã€ownerプãƒã‚ã‚·ã®å¾©å…ƒã‚’ã—ã¾ã™ã€‚ ã“ã®æŒ¯ã‚‹èˆžã„ã‚’ <literal>Person</literal> ã®ãƒžãƒƒãƒ”ング㮠<literal>batch-size</literal> ã®æŒ‡å®šã§èª¿æ•´ã§ãã¾ã™ã€‚"
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr "Hibernateã¯ã‚¯ã‚¨ãƒªã‚’３回ã ã‘を実行ã™ã‚‹ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚パターンã¯10, 10, 5ã§ã™ã€‚"
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr "コレクションã®ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã‚‚有効ã«ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚例ã¨ã—ã¦ã€ãã‚Œãžã‚Œã® <literal>Person</literal> ㌠<literal>Cat</literal> ã®é…延コレクションをæŒã£ã¦ãŠã‚Šã€ 10個ã®Person㌠<literal>Sesssion</literal> ã«ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã¨ã™ã‚‹ã¨ã€ã™ã¹ã¦ã®Person㫠対ã—ã¦ç¹°ã‚Šè¿”ã— <literal>getCats()</literal> を呼ã³å‡ºã™ã“ã¨ã§ã€è¨ˆ10回㮠<literal>SELECT</literal> ãŒç™ºç”Ÿã—ã¾ã™ã€‚ã‚‚ã— <literal>Person</literal> ã®ãƒžãƒƒãƒ”ング㧠<literal>cats</literal> コレクションã®ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã‚’有効ã«ã™ã‚Œã°ã€Hibernateã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®äº‹å‰ãƒ•ã‚§ãƒƒãƒãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">
+\n"
+ " <set name=\"cats\" batch-size=\"3\">
+\n"
+ " ...
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr "<literal>batch-size</literal> ãŒ3ãªã®ã§ã€Hibernateã¯4回㮠<literal>SELECT</literal> ã§3個ã€3個ã€3個ã€1個をãƒãƒ¼ãƒ‰ã—ã¾ã™ã€‚ç¹°ã‚Šè¿”ã™ã¨ã€å±žæ€§ã®å€¤ã¯ç‰¹å®šã® <literal>Session</literal> ã®ä¸ã®åˆæœŸåŒ–ã•ã‚Œã¦ã„ãªã„コレクションã®æœŸå¾…æ•°ã«ä¾å˜ã—ã¾ã™ã€‚"
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr "コレクションã®ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã¯ã‚¢ã‚¤ãƒ†ãƒ ã®ãƒã‚¹ãƒˆã—ãŸãƒ„リー〠ã™ãªã‚ã¡ã€ä»£è¡¨çš„ãªéƒ¨å“表ã®ãƒ‘ターン㌠ã‚ã‚‹å ´åˆã«ç‰¹ã«æœ‰ç”¨ã§ã™ã€‚（ã—ã‹ã—ã€èªã¿è¾¼ã¿ãŒå¤šã„ツリーã§ã¯ <emphasis>ãƒã‚¹ãƒˆã—ãŸset</emphasis> ã‚„ <emphasis>具体化ã—ãŸãƒ‘ス</emphasis> ãŒã‚ˆã‚Šã‚ˆã„é¸æŠžã«ãªã‚Šã¾ã™ã€‚）"
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr "サブセレクトフェッãƒã®ä½¿ç”¨"
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr "一ã¤ã®é…延コレクションやå˜ä¸€å€¤ãƒ—ãƒã‚ã‚·ãŒãƒ•ã‚§ãƒƒãƒã•ã‚Œãªã‘ã‚Œã°ã„ã‘ãªã„ã¨ãã€Hibernate㯠ãれらã™ã¹ã¦ã‚’ãƒãƒ¼ãƒ‰ã—ã€ã‚µãƒ–セレクトã®ã‚ªãƒªã‚¸ãƒŠãƒ«ã‚¯ã‚¨ãƒªãŒå†åº¦å®Ÿè¡Œã•ã‚Œã¾ã™ã€‚ã“れ㯠ãƒãƒƒãƒãƒ•ã‚§ãƒƒãƒã¨åŒã˜æ–¹æ³•ã§å‹•ãã€å°‘ã—ãšã¤ã®ãƒãƒ¼ãƒ‰ã¯è¡Œã„ã¾ã›ã‚“。"
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr "é…延プãƒãƒ‘ティフェッãƒã®ä½¿ç”¨"
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr "Hibernate3ã¯ãƒ—ãƒãƒ‘ティã”ã¨ã®é…延フェッãƒã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ã“ã®æœ€é©åŒ–手法㯠<emphasis>グループã®ãƒ•ã‚§ãƒƒãƒ</emphasis> ã¨ã—ã¦ã‚‚知られã¦ã„ã¾ã™ã€‚ã“ã‚Œã¯ã»ã¨ã‚“ã© è¦æœ›ã‹ã‚‰å‡ºãŸæ©Ÿèƒ½ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。実際ã«ã¯åˆ—èªã¿è¾¼ã¿ã®æœ€é©åŒ–よりも〠行èªã¿è¾¼ã¿ã®æœ€é©åŒ–ãŒéžå¸¸ã«é‡è¦ã§ã™ã€‚ ã—ã‹ã—ã€ã‚¯ãƒ©ã‚¹ã®ã„ãã¤ã‹ã®ãƒ—ãƒãƒ‘ティã ã‘ã‚’èªã¿è¾¼ã‚€ã“ã¨ã¯ã€æ—¢å˜ã®ãƒ†ãƒ¼ãƒ–ルãŒä½•ç™¾ã‚‚ã®åˆ—ã‚’æŒã¡ã€ データモデルを改善ã§ããªã„ãªã©ã®æ¥µç«¯ãªå ´åˆã«ã¯æœ‰ç”¨ã§ã™ã€‚"
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr "é…延プãƒãƒ‘ティèªã¿è¾¼ã¿ã‚’有効ã«ã™ã‚‹ã«ã¯ã€å¯¾è±¡ã®ãƒ—ãƒãƒ‘ティã®ãƒžãƒƒãƒ”ング㧠<literal>lazy</literal> 属性をセットã—ã¦ãã ã•ã„。"
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Document\">
+\n"
+ " <id name=\"id\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>
+\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>
+\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr "é…延プãƒãƒ‘ティèªã¿è¾¼ã¿ã¯ãƒ“ルド時ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ã‚’å¿…è¦ã¨ã—ã¾ã™ï¼ã‚‚㗠永続クラスã«çµ„ã¿è¾¼ã¿ãŒã•ã‚Œã¦ã„ãªã„ãªã‚‰ã€Hibernateã¯é»™ã£ã¦é…延プãƒãƒ‘ティã®è¨å®šã‚’無視ã—ã¦ã€ å³æ™‚フェッãƒã«æˆ»ã—ã¾ã™ã€‚"
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr "ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ã¯ä»¥ä¸‹ã®Antタスクを使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">
+\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">
+\n"
+ " <classpath path=\"${jar.path}\"/>
+\n"
+ " <classpath path=\"${classes.dir}\"/>
+\n"
+ " <classpath refid=\"lib.class.path\"/>
+\n"
+ " </taskdef>
+\n"
+ "
+\n"
+ " <instrument verbose=\"true\">
+\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">
+\n"
+ " <include name=\"*.class\"/>
+\n"
+ " </fileset>
+\n"
+ " </instrument>
+\n"
+ "</target>]]>"
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr "ä¸è¦ãªåˆ—ã‚’èªã¿è¾¼ã¾ãªã„ãŸã‚ã®ã€åˆ¥ã®ï¼ˆã‚ˆã‚Šã‚ˆã„？）方法ã¯ã€å°‘ãªãã¨ã‚‚ èªã¿è¾¼ã¿ã®ã¿ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«ãŠã„ã¦ã¯ã€HQLã‚„Criteriaクエリã®å°„å½± 機能を使ã†ã“ã¨ã§ã™ã€‚ã“ã®æ–¹æ³•ã¯ãƒ“ルド時ã®ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰çµ„ã¿è¾¼ã¿ãŒä¸è¦ã«ãªã‚Šã€ より良ã„解決方法ã§ã™ã€‚"
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr "HQL㧠<literal>fetch all properties</literal> を使ã†ã“ã¨ã§ã€æ™®é€šã©ãŠã‚Šã® プãƒãƒ‘ティã®å³æ™‚フェッãƒãƒ³ã‚°ã‚’強制ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr "第2レベルã‚ャッシュ"
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr "Hibernateã® <literal>Session</literal> ã¯æ°¸ç¶šãƒ‡ãƒ¼ã‚¿ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ¬ãƒ™ãƒ«ã®ã‚ャッシュã§ã™ã€‚ class-by-classã¨collection-by-collectionã”ã¨ã®ã€ã‚¯ãƒ©ã‚¹ã‚¿ãƒ¬ãƒ™ãƒ«ã‚„JVMレベル （ <literal>SessionFactory</literal> レベル）ã®ã‚ャッシュをè¨å®šã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ クラスタ化ã•ã‚ŒãŸã‚ャッシュã«ã¤ãªãã“ã¨ã•ãˆå‡ºæ¥ã¾ã™ã€‚ã—ã‹ã—注æ„ã—ã¦ãã ã•ã„。 ã‚ャッシュã¯ä»–ã®ã‚¢ãƒ—リケーションã«ã‚ˆã‚‹æ°¸ç¶šå±¤ã®å¤‰æ›´ã‚’ 考慮ã—ã¾ã›ã‚“（ã‚ャッシュデータを定期的ã«æœŸé™åˆ‡ã‚Œã«ã™ã‚‹è¨å®šã¯å‡ºæ¥ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr "HibernateãŒä½¿ç”¨ã™ã‚‹ã‚ャッシュ実装ã¯ã€<literal>hibernate.cache.provider_class</literal> プãƒãƒ‘ティ㫠<literal>org.hibernate.cache.CacheProvider</literal> を実装ã—ãŸã‚¯ãƒ©ã‚¹åを指定ã™ã‚‹ã“ã¨ã§å¤‰æ›´ã§ãã¾ã™ã€‚ Hibernateã¯å¤šãã®ã‚ªãƒ¼ãƒ—ンソースã®ã‚ャッシュプãƒãƒã‚¤ãƒ€ã‚’ビルトイン実装ã§æŒã£ã¦ã„ã¾ã™ï¼ˆå¾Œã«ãƒªã‚¹ãƒˆãŒã‚ã‚Šã¾ã™ï¼‰ã€‚ åŠ ãˆã¦ã€å‰ã«èª¬æ˜Žã—ãŸã‚ˆã†ã«ã€ã‚ãªãŸè‡ªèº«ãŒç‹¬è‡ªã®å®Ÿè£…ã‚’ã—ã¦ã€ãれを組ã¿è¾¼ã‚€ã“ã¨ã‚‚出æ¥ã¾ã™ã€‚ ãƒãƒ¼ã‚¸ãƒ§ãƒ³3.2よりå‰ã§ã¯EhCacheãŒãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®ã‚ャッシュプãƒãƒã‚¤ãƒ€ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ãƒãƒ¼ã‚¸ãƒ§ãƒ³3.2ã§ã¯ã“ã‚Œã¯å½“ã¦ã¯ã¾ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr "ã‚ャッシュプãƒãƒã‚¤ãƒ€"
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr "ã‚ャッシュ"
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr "プãƒãƒã‚¤ãƒ€ã‚¯ãƒ©ã‚¹"
+
+#: index.docbook:603
+msgid "Type"
+msgstr "<entry>タイプ</entry>"
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr "クラスタセーフ"
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr "クエリã‚ャッシュã®ã‚µãƒãƒ¼ãƒˆ"
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr "Hashtable（製å“用ã¨ã—ã¦æ„図ã—ã¦ã„ã¾ã›ã‚“）"
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr "org.hibernate.cache.HashtableCacheProvider"
+
+#: index.docbook:612
+msgid "memory"
+msgstr "<entry>メモリ</entry>"
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr "<entry>yes</entry>"
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr "EHCache"
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr "org.hibernate.cache.EhCacheProvider"
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr "メモリã€ãƒ‡ã‚£ã‚¹ã‚¯"
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr "OSCache"
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr "org.hibernate.cache.OSCacheProvider"
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr "<entry>yes</entry>"
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr "SwarmCache"
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr "org.hibernate.cache.SwarmCacheProvider"
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr "クラスタ（ipマルãƒã‚ャスト）"
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr "yes（クラスタ無効化）"
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr "JBoss TreeCache"
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr "org.hibernate.cache.TreeCacheProvider"
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr "クラスタ（ipマルãƒã‚ャスト）ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒŠãƒ«"
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr "yes（複製）"
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr "yes（時刻åŒæœŸãŒå¿…è¦ï¼‰"
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr "ã‚ャッシュã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr "クラスやコレクションã®ãƒžãƒƒãƒ”ング㮠<literal><cache></literal> è¦ç´ ã¯ä»¥ä¸‹ã®å½¢å¼ã§ã™ã€‚"
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+ "<![CDATA[<cache
+\n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"
+\n"
+ " region=\"RegionName\"
+\n"
+ " include=\"all|non-lazy\"
+\n"
+ "/>]]>"
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr "ã¾ãŸã¯ï¼ˆã‚ˆã‚Šã‚ˆã„方法ã¨ã—ã¦ï¼Ÿï¼‰ã€ <literal>hibernate.cfg.xml</literal> ã« <literal><class-cache></literal> 㨠<literal><collection-cache></literal> è¦ç´ を指定ã™ã‚‹ã“ã¨ã‚‚出æ¥ã¾ã™ã€‚"
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr "<literal>usage</literal> 属性㯠<emphasis>ã‚ャッシュã®ä¸¦åˆ—性戦略</emphasis> を指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr "read only戦略"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr "ã‚‚ã—アプリケーションãŒèªã¿è¾¼ã¿ã®ã¿å¿…è¦ã§ã€æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’変更ã—ãªã„ãªã‚‰ã€ <literal>read-only</literal> ã‚ャッシュを使ã†ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ã“ã‚Œã¯ã‚‚ã£ã¨ã‚‚å˜ç´”㧠もã£ã¨ã‚‚パフォーマンスã®è‰¯ã„戦略ã§ã™ã€‚クラスタã§ã®ä½¿ç”¨ã‚‚完全ã«å®‰å…¨ã§ã™ã€‚"
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">
+\n"
+ " <cache usage=\"read-only\"/>
+\n"
+ " ....
+\n"
+ "</class>]]>"
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr "read/write戦略"
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr "アプリケーションãŒãƒ‡ãƒ¼ã‚¿ã‚’æ›´æ–°ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãªã‚‰ã€ <literal>read-write</literal> ã‚ャッシュãŒé©å½“ã‹ã‚‚ ã—ã‚Œã¾ã›ã‚“。ã“ã®ã‚ャッシュ戦略ã¯ã€ã‚·ãƒªã‚¢ãƒ©ã‚¤ã‚¶ãƒ–ルãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³åˆ†é›¢ãƒ¬ãƒ™ãƒ«ãŒè¦æ±‚ã•ã‚Œã‚‹ãªã‚‰ã€ 決ã—ã¦ä½¿ã†ã¹ãã§ã¯ã‚ã‚Šã¾ã›ã‚“。もã—ã‚ャッシュãŒJTA環境ã§ä½¿ã‚れるãªã‚‰ã€JTA <literal>TransactionManager</literal> ã‚’å–å¾—ã™ã‚‹ãŸã‚ã®æ–¹æ³•ã‚’示㙠<literal>hibernate.transaction.manager_lookup_class</literal> プãƒãƒ‘ティを指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。他ã®ç’°å¢ƒã§ã¯ã€ <literal>Session.close()</literal> ã‚„ <literal>Session.disconnect()</literal> ãŒå‘¼ã°ã‚ŒãŸã¨ãã«ã€ç¢ºå®Ÿã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒå®Œäº† ã—ã¦ã„ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã‚‚ã—クラスタã§ã“ã®æˆ¦ç•¥ã‚’使ã„ãŸã„ãªã‚‰ã€åŸºã¨ãªã‚‹ã‚ャッシュã®å®Ÿè£…ãŒãƒãƒƒã‚¯ã‚’サãƒãƒ¼ãƒˆ ã—ã¦ã„ã‚‹ã“ã¨ã‚’ä¿è¨¼ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 çµ!
„ã¿è¾¼ã¿ã®ã‚ャッシュプãƒãƒã‚¤ãƒ€ã¯ <emphasis>サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“</emphasis> 。"
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >
+\n"
+ " <cache usage=\"read-write\"/>
+\n"
+ " ....
+\n"
+ " <set name=\"kittens\" ... >
+\n"
+ " <cache usage=\"read-write\"/>
+\n"
+ " ....
+\n"
+ " </set>
+\n"
+ "</class>]]>"
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr "厳密ã§ã¯ãªã„read/write戦略"
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr "アプリケーションãŒãŸã¾ã«ã—ã‹ãƒ‡ãƒ¼ã‚¿ã‚’æ›´æ–°ã™ã‚‹å¿…è¦ã¯ãªã（ã™ãªã‚ã¡äºŒã¤ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒ åŒæ™‚ã«åŒã˜ã‚¢ã‚¤ãƒ†ãƒ ã‚’æ›´æ–°ã—よã†ã¨ã™ã‚‹ã“ã¨ã¯ã»ã¨ã‚“ã©èµ·ã“らãªã„）ã€åŽ³å¯†ãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³åˆ†é›¢ãŒ è¦æ±‚ã•ã‚Œãªã„ãªã‚‰ã€ <literal>nonstrict-read-write</literal> ã‚ャッシュãŒé©å½“ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã‚‚ã—ã‚ャッシュãŒJTA環境ã§ä½¿ã‚れるãªã‚‰ã€ <literal>hibernate.transaction.manager_lookup_class</literal> を指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。他ã®ç’°å¢ƒã§ã¯ã€ <literal>Session.close()</literal> ã‚„ <literal>Session.disconnect()</literal> ãŒå‘¼ã°ã‚ŒãŸã¨ãã«ã€ç¢ºå®Ÿã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒå®Œäº† ã—ã¦ã„ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "transactional戦略"
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr "<literal>transactional</literal> ã‚ャッシュ戦略ã¯JBoss TreeCacheã®ã‚ˆã†ãªå®Œå…¨ãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒŠãƒ« ã‚ャッシュプãƒãƒã‚¤ãƒ€ã®ã‚µãƒãƒ¼ãƒˆã‚’æä¾›ã—ã¾ã™ã€‚ ã“ã®ã‚ˆã†ãªã‚ャッシュã¯JTA環境ã§ã®ã¿ä½¿ç”¨å¯èƒ½ã§ã€ <literal>hibernate.transaction.manager_lookup_class</literal> を指定ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr "ã™ã¹ã¦ã®åŒæ™‚並行性ã‚ャッシュ戦略をサãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹ã‚ャッシュプãƒãƒã‚¤ãƒ€ã¯ã‚ã‚Šã¾ã›ã‚“。 以下ã®è¡¨ã¯ã©ã®ãƒ—ãƒãƒã‚¤ãƒ€ãŒã©ã®åŒæ™‚並列性戦略ã«å¯¾å¿œã™ã‚‹ã‹ã‚’表ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:775
+msgid "read-only"
+msgstr "ã‚ャッシュ"
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr "read-only"
+
+#: index.docbook:777
+msgid "read-write"
+msgstr "厳密ã§ã¯ãªã„read-write"
+
+#: index.docbook:778
+msgid "transactional"
+msgstr "read-write"
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr "<entry>yes</entry>"
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr "ã‚ャッシュã®ç®¡ç†"
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr "オブジェクトを <literal>save()</literal> 〠<literal>update()</literal> 〠<literal>saveOrUpdate()</literal> ã«æ¸¡ã™ã¨ãã€ãã—㦠<literal>load()</literal> 〠<literal>get()</literal> 〠<literal>list()</literal> 〠<literal>iterate()</literal> 〠<literal>scroll()</literal> を使ã£ã¦ã‚ªãƒ–ジェクトを復元ã™ã‚‹ã¨ãã«ã¯å¸¸ã«ã€ ãã®ã‚ªãƒ–ジェクト㯠<literal>Session</literal> ã®å†…部ã‚ャッシュã«è¿½åŠ ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr "次㫠<literal>flush()</literal> ãŒå‘¼ã°ã‚Œã‚‹ã¨ã€ã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¨åŒæœŸåŒ–ã•ã‚Œã¾ã™ã€‚ ã‚‚ã—ã“ã®åŒæœŸãŒèµ·ã“ã‚‹ã“ã¨ã‚’望ã¾ãªã„ã¨ãã‚„ã€è†¨å¤§ãªæ•°ã®ã‚ªãƒ–ジェクトを処ç†ã—ã¦ã„ã¦ãƒ¡ãƒ¢ãƒªã‚’効率的㫠扱ã†å¿…è¦ãŒã‚ã‚‹ã¨ãã¯ã€ <literal>evict()</literal> メソッドを使ã£ã¦ä¸€æ¬¡ã‚ャッシュã‹ã‚‰ オブジェクトやコレクションを削除ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set
+\n"
+ "while ( cats.next() ) {
+\n"
+ " Cat cat = (Cat) cats.get(0);
+\n"
+ " doSomethingWithACat(cat);
+\n"
+ " sess.evict(cat);
+\n"
+ "}]]>"
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr "<literal>Session</literal> ã¯ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚ャッシュã«å«ã¾ã‚Œã‚‹ã‹ã©ã†ã‹ã‚’判æ–ã™ã‚‹ãŸã‚ã® <literal>contains()</literal> メソッドもæä¾›ã—ã¾ã™ã€‚"
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr "ã™ã¹ã¦ã®ã‚ªãƒ–ジェクトをセッションã‚ャッシュã‹ã‚‰å®Œå…¨ã«å–り除ãã«ã¯ã€<literal>Session.clear()</literal> を呼ã³å‡ºã—ã¦ãã ã•ã„。"
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr "二次ã‚ャッシュã®ãŸã‚ã«ã€ <literal>SessionFactory</literal> ã«ã¯ インスタンスã€ã‚¯ãƒ©ã‚¹å…¨ä½“ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³å…¨ä½“ã‚’ã‚ャッシュã‹ã‚‰ 削除ã™ã‚‹ãŸã‚ã®ãƒ¡ã‚½ãƒƒãƒ‰ãŒãã‚Œãžã‚Œå®šç¾©ã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat
+\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats
+\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens
+\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr "<literal>CacheMode</literal> ã¯ç‰¹å®šã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ãŒäºŒæ¬¡ã‚ャッシュã¨ã©ã®ã‚ˆã†ã«ç›¸äº’作用ã™ã‚‹ã‹ã‚’ 指定ã—ã¾ã™ã€‚"
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr "<literal>CacheMode.NORMAL</literal> - アイテムã®èªã¿è¾¼ã¿ã¨æ›¸ãè¾¼ã¿ã§äºŒæ¬¡ã‚ャッシュを使ã„ã¾ã™"
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr "<literal>CacheMode.GET</literal> - èªã¿è¾¼ã¿ã¯äºŒæ¬¡ã‚ャッシュã‹ã‚‰è¡Œã„ã¾ã™ãŒã€ãƒ‡ãƒ¼ã‚¿ã‚’ æ›´æ–°ã—ãŸå ´åˆã‚’除ã„ã¦äºŒæ¬¡ã‚ャッシュã«æ›¸ãè¾¼ã¿ã‚’ã—ã¾ã›ã‚“。"
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr "<literal>CacheMode.PUT</literal> - 二次ã‚ャッシュã«ã‚¢ã‚¤ãƒ†ãƒ を書ãè¾¼ã¿ã¾ã™ãŒã€èªã¿è¾¼ã¿ã«ã¯ 二次ã‚ャッシュを使ã„ã¾ã›ã‚“。"
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr "<literal>CacheMode.REFRESH</literal> - 二次ã‚ャッシュã«ã‚¢ã‚¤ãƒ†ãƒ を書ãè¾¼ã¿ã¾ã™ãŒã€èªã¿è¾¼ã¿ã«ã¯ 二次ã‚ャッシュを使ã‚ãšã€ <literal>hibernate.cache.use_minimal_puts</literal> ã®å½±éŸ¿ã‚’å—ã‘ãšã«ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰èªã¿è¾¼ã‚€ã™ã¹ã¦ã®ã‚¢ã‚¤ãƒ†ãƒ ã®äºŒæ¬¡ã‚ャッシュを強制的ã«ãƒªãƒ•ãƒ¬ãƒƒã‚·ãƒ¥ã—ã¾ã™ã€‚"
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr "二次ã‚ャッシュã®å†…容やクエリã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã‚’è¦‹ã‚‹ãŸã‚ã«ã€ <literal>Statistics</literal> APIã‚’ 使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()
+\n"
+ " .getSecondLevelCacheStatistics(regionName)
+\n"
+ " .getEntries();]]>"
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr "çµ±è¨ˆæƒ…å ±ã‚’æœ‰åŠ¹ã«ã—ã¦ã€ã•ã‚‰ã«ã‚ªãƒ—ションã¨ã—ã¦ã€ã‚ャッシュエントリを 人ãŒã‚ˆã‚Šç†è§£å¯èƒ½ãªå½¢å¼ã§ä¿æŒã™ã‚‹ã“ã¨ã‚’Hibernateã«å¼·åˆ¶ã—ã¾ã™ã€‚"
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr ""
+ "<![CDATA[hibernate.generate_statistics true
+\n"
+ "hibernate.cache.use_structured_entries true]]>"
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr "クエリã‚ャッシュ"
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr "クエリã®ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚‚ã‚ャッシュ出æ¥ã¾ã™ã€‚ã“ã‚Œã¯åŒã˜ãƒ‘ラメータã§ä½•åº¦ã‚‚実行ã•ã‚Œã‚‹ クエリã«å¯¾ã—ã¦ã®ã¿æœ‰ç”¨ã§ã™ã€‚クエリã‚ャッシュを使ã†ã«ã¯ã€ã¾ãšè¨å®šã§æœ‰åŠ¹ã«ã—ãªãã¦ã¯ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr "<![CDATA[hibernate.cache.use_query_cache true]]>"
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr "ã“ã®è¨å®šã¯æ–°ãŸã«äºŒã¤ã®ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã®ä½œæˆã‚’è¡Œã„ã¾ã™ã€‚一ã¤ã¯ã‚¯ã‚¨ãƒªã®ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã® ã‚ャッシュ（ <literal>org.hibernate.cache.StandardQueryCache</literal> ）をä¿æŒã—〠もã†1ã¤ã¯ã‚¯ã‚¨ãƒªå¯èƒ½ãªãƒ†ãƒ¼ãƒ–ルã¸ã®æœ€æ–°ã®æ›´æ–°ã‚¿ã‚¤ãƒ スタンプ （ <literal>org.hibernate.cache.UpdateTimestampsCache</literal> ）をä¿æŒã—ã¾ã™ã€‚ クエリã‚ャッシュã¯ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã®å®Ÿéš›ã®è¦ç´ ã®çŠ¶æ…‹ã¯ã‚ャッシュã—ãªã„ã“ã¨ã« 注æ„ã—ã¦ãã ã•ã„。ã‚ャッシュã™ã‚‹ã®ã¯è˜åˆ¥åã®å€¤ã¨ã€å€¤åž‹ã®çµæžœã®ã¿ã§ã™ã€‚ ãã®ãŸã‚ã€ã‚¯ã‚¨ãƒªã‚ャッシュã¯å¸¸ã«äºŒæ¬¡ã‚ャッシュã¨ä¸€ç·’ã«ä½¿ã†ã¹ãã§ã™ã€‚"
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr "ã»ã¨ã‚“ã©ã®ã‚¯ã‚¨ãƒªã¯ã‚ャッシュã®æ©æµã‚’å—ã‘ãªã„ã®ã§ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯ã‚¯ã‚¨ãƒªã¯ã‚ャッシュã•ã‚Œã¾ã›ã‚“。 ã‚ャッシュを有効ã«ã™ã‚‹ã«ã¯ã€ <literal>Query.setCacheable(true)</literal> を呼ã³å‡ºã—ã¦ãã ã•ã„。 ãã†ã™ã‚Œã°ã‚¯ã‚¨ãƒªãŒæ—¢å˜ã®ã‚ャッシュçµæžœã‚’探ã—ã€ã‚¯ã‚¨ãƒªå®Ÿè¡Œæ™‚ã«ãã®çµæžœã‚’ã‚ャッシュã«è¿½åŠ ã™ã‚‹ よã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr "クエリã‚ャッシュã®ç ´æ£„ãƒãƒªã‚·ãƒ¼ã‚’ç´°ã‹ã制御ã—ãŸã„ã¨ãã¯ã€ <literal>Query.setCacheRegion()</literal> を呼ã³å‡ºã—ã¦ç‰¹å®šã®ã‚¯ã‚¨ãƒªã«å¯¾ã™ã‚‹ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã‚’æŒ‡å®šã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")
+\n"
+ " .setEntity(\"blogger\", blogger)
+\n"
+ " .setMaxResults(15)
+\n"
+ " .setCacheable(true)
+\n"
+ " .setCacheRegion(\"frontpages\")
+\n"
+ " .list();]]>"
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr "クエリãŒè‡ªèº«ã®ã‚¯ã‚¨ãƒªã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã®ãƒªãƒ•ãƒ¬ãƒƒã‚·ãƒ¥ã‚’強制ã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ãªã‚‰ã€ <literal>Query.setCacheMode(CacheMode.REFRESH)</literal> を呼ã³å‡ºã™ã¹ãã§ã™ã€‚ã“れ㯠元ã¨ãªã‚‹ãƒ‡ãƒ¼ã‚¿ãŒåˆ¥ã®ãƒ—ãƒã‚»ã‚¹ã«ã‚ˆã£ã¦æ›´æ–°ã•ã‚ŒãŸã‚Šï¼ˆã™ãªã‚ã¡Hibernateを通ã˜ã¦æ›´æ–°ã•ã‚Œãªã„）〠アプリケーションã«ç‰¹å®šã®ã‚¯ã‚¨ãƒªãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’é¸æŠžã—ã¦ãƒªãƒ•ãƒ¬ãƒƒã‚·ãƒ¥ã•ã›ã‚‹å ´åˆã«ç‰¹ã«æœ‰ç”¨ã§ã™ã€‚ ã•ã‚‰ã«æœ‰ç”¨ãªã‚‚ã†ä¸€ã¤ã®æ–¹æ³•ã¯ã€ <literal>SessionFactory.evictQueries()</literal> ã«ã‚ˆã£ã¦ã‚¯ã‚¨ãƒªã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã‚’æ¶ˆåŽ»ã™ã‚‹ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr "☆14.1"
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr "コレクションã®ãƒ‘フォーマンスã®ç†è§£"
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr "コレクションã®è©±é¡Œã«ã¯ã™ã§ã«å¤šãã®æ™‚間を使ã„ã¾ã—ãŸã€‚ã“ã®ç¯€ã§ã¯ コレクションãŒå®Ÿè¡Œæ™‚ã«ã©ã®ã‚ˆã†ã«æŒ¯èˆžã†ã‹ã«ã¤ã„ã¦ã®è©±é¡Œã‚’2ã€3å–り上ã’ã¾ã™ã€‚"
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr "<title>分類</title>"
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr "Hibernateã¯3ã¤ã®åŸºæœ¬çš„ãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ç¨®é¡žã‚’定義ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr "値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr "一対多関連"
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr "多対多関連"
+
+#: index.docbook:994
+msgid "sets"
+msgstr "ã“ã®åˆ†é¡žã¯ã•ã¾ã–ã¾ãªãƒ†ãƒ¼ãƒ–ルや外部ã‚ー関連を区別ã—ã¾ã™ãŒã€ç§ãŸã¡ãŒçŸ¥ã‚‹å¿…è¦ã®ã‚ã‚‹ 関連モデルã«ã¤ã„ã¦ã»ã¨ã‚“ã©ãªã«ã‚‚æ•™ãˆã¦ãã‚Œã¾ã›ã‚“ã€‚é–¢é€£æ§‹é€ ã‚„ãƒ‘ãƒ•ã‚©ãƒ¼ãƒžãƒ³ã‚¹ã®ç‰¹å¾´ã‚’ 完全ã«ç†è§£ã™ã‚‹ã«ã¯ã€HibernateãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¡Œã‚’æ›´æ–°ã€å‰Šé™¤ã™ã‚‹ãŸã‚ã«ä½¿ã†ä¸»ã‚ãƒ¼ã® æ§‹é€ ã‚‚ã¾ãŸè€ƒãˆãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。ã“ã‚Œã¯ä»¥ä¸‹ã®åˆ†é¡žã‚’æ示ã—ã¾ã™ã€‚"
+
+#: index.docbook:997
+msgid "bags"
+msgstr "インデックス付ãコレクション"
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr "<para>set</para>"
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr "<para>bag</para>"
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr "ã™ã¹ã¦ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãコレクション（mapã€listã€é…列）㯠<literal><key></literal> 㨠<literal><index></literal> カラムã‹ã‚‰ãªã‚‹ä¸»ã‚ーをæŒã£ã¦ã„ã¾ã™ã€‚ã“ã®å ´åˆã¯ コレクションã®æ›´æ–°ã¯éžå¸¸ã«åŠ¹çŽ‡çš„ã§ã™ã€‚主ã‚ーã¯æœ‰ç”¨ãªã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã«ãªã‚Šã€Hibernate㌠特定ã®è¡Œã‚’æ›´æ–°ã¾ãŸã¯å‰Šé™¤ã™ã‚‹ã¨ãã«ã€ãã®è¡Œã‚’効率的ã«è¦‹ã¤ã‘ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr "set㯠<literal><key></literal> ã‹ã‚‰ãªã‚‹ä¸»ã‚ーã¨è¦ç´ ã®ã‚«ãƒ©ãƒ ã‚’æŒã£ã¦ã„ã¾ã™ã€‚ ã“ã‚Œã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³è¦ç´ ã®ã„ãã¤ã‹ã®åž‹ã«ã¤ã„ã¦ã¯åŠ¹çŽ‡çš„ã§ã¯ãªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 特ã«è¤‡åˆè¦ç´ ã€å¤§ããªãƒ†ã‚ストã€ãƒã‚¤ãƒŠãƒªãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã§ã¯éžåŠ¹çŽ‡ã§ã™ã€‚データベース㯠複åˆä¸»ã‚ーã«åŠ¹çŽ‡çš„ã«ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’付ã‘ã‚‹ã“ã¨ãŒã§ããªã„ã‹ã‚‰ã§ã™ã€‚一方ã€1対多や多対多関連ã«ãŠã„ã¦ã€ 特ã«äººå·¥è˜åˆ¥åã®å ´åˆã¯åŒã˜ãらã„効率的ã§ã™ã€‚（余談： <literal>SchemaExport</literal> ã§å®Ÿéš›ã« <literal><set></literal> ã®ä¸»ã‚ーを作りãŸã„ãªã‚‰ã€ã™ã¹ã¦ã®ã‚«ãƒ©ãƒ 㧠<literal>not-null=\"true\"</literal> を宣言ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。）"
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr "<literal><idbag></literal> マッピングã¯ä»£ç†ã‚ーを定義ã—ã¾ã™ã€‚ãã®ãŸã‚ æ›´æ–°ã¯å¸¸ã«éžå¸¸ã«åŠ¹çŽ‡çš„ã§ã™ã€‚事実上ã€ã“ã‚Œã¯æœ€å–„ã®ã‚±ãƒ¼ã‚¹ã§ã™ã€‚"
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr "bagã¯æœ€æ‚ªã®ã‚±ãƒ¼ã‚¹ã§ã™ã€‚bagã¯è¦ç´ ã®å€¤ã®é‡è¤‡ãŒå¯èƒ½ã§ã€ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚«ãƒ©ãƒ ã‚’æŒãŸãªã„ãŸã‚〠主ã‚ーã¯å®šç¾©ã•ã‚Œãªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。Hibernateã«ã¯é‡è¤‡ã—ãŸè¡Œã‚’区別ã™ã‚‹æ–¹æ³•ãŒã‚ã‚Šã¾ã›ã‚“。 Hibernateã¯ã“ã®å•é¡Œã®è§£æ±ºã®ãŸã‚ã«ã€å¤‰æ›´ãŒã‚ã£ãŸã¨ãã«ã¯å¸¸ã«å®Œå…¨ãªå‰Šé™¤ （一ã¤ã® <literal>DELETE</literal> ã«ã‚ˆã‚‹ï¼‰ã‚’è¡Œã„ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å†ä½œæˆã‚’è¡Œã„ã¾ã™ã€‚ ã“ã‚Œã¯éžå¸¸ã«éžåŠ¹çŽ‡çš„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr "1対多関連ã§ã¯ã€ã€Œä¸»ã‚ーã€ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ãƒ†ãƒ¼ãƒ–ルã®ç‰©ç†çš„㪠主ã‚ーã§ã¯ãªã„ã‹ã‚‚ã—ã‚Œãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。ã—ã‹ã—ã“ã®å ´åˆã§ã•ãˆã€ä¸Šè¨˜ã®åˆ†é¡žã¯ã¾ã 有用ã§ã™ã€‚ （HibernateãŒã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å€‹ã€…ã®è¡Œã‚’ã©ã†ã‚„ã£ã¦ã€Œè¦‹ã¤ã‘ã‚‹ã‹ã€ã‚’表ã—ã¦ã„ã¾ã™ã€‚）"
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr "æ›´æ–°ã«ã‚‚ã£ã¨ã‚‚効率的ãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ listã€mapã€idbagã€set"
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr "上ã§ã®è°è«–ã‹ã‚‰ã€ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãコレクションã¨ï¼ˆæ™®é€šã®ï¼‰setã¯è¦ç´ ã®è¿½åŠ ã€å‰Šé™¤ã€ æ›´æ–°ã§ã‚‚ã£ã¨ã‚‚効率的ãªæ“作ãŒå‡ºæ¥ã‚‹ã“ã¨ã¯æ˜Žã‚‰ã‹ã§ã™ã€‚"
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr "ã»ã¼é–“é•ã„ãªãã€å¤šå¯¾å¤šé–¢é€£ã‚„値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ãŠã„ã¦ã€ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãコレクション㌠setよりも優れã¦ã„る点ãŒä¸€ã¤ä»¥ä¸Šã‚ã‚Šã¾ã™ã€‚ <literal>Set</literal> ã¯ãã® æ§‹é€ ã®ãŸã‚ã«ã€Hibernateã¯è¦ç´ ãŒã€Œå¤‰æ›´ã€ã•ã‚ŒãŸã¨ãã«è¡Œã‚’決ã—㦠<literal>UPDATE</literal> ã—ã¾ã›ã‚“。 <literal>Set</literal> ã¸ã®å¤‰æ›´ã¯å¸¸ã«ï¼ˆå€‹ã€…ã®è¡Œã®ï¼‰<literal>INSERT</literal> 㨠<literal>DELETE</literal> ã«ã‚ˆã£ã¦è¡Œã„ã¾ã™ã€‚ç¹°ã‚Šè¿”ã—ã¾ã™ãŒã€ã“ã‚Œã¯ä¸€å¯¾å¤šé–¢é€£ã«ã¯ 当ã¦ã¯ã¾ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr "é…列ã¯é…延処ç†ãŒã§ããªã„ã¨ã„ã†æ±ºã¾ã‚Šãªã®ã§ã€çµè«–ã¨ã—ã¦ã€listã€mapã€idbagãŒã‚‚ã£ã¨ã‚‚ パフォーマンスã®è‰¯ã„（inverseã§ã¯ãªã„）コレクションタイプã¨ãªã‚Šã¾ã™ã€‚setã‚‚ ãã‚Œã»ã©é•ã„ã¯ã‚ã‚Šã¾ã›ã‚“。Hibernateã®ã‚¢ãƒ—リケーションã§ã¯ã€setã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚‚ã£ã¨ã‚‚ 共通ã®ç¨®é¡žã¨ã—ã¦æœŸå¾…ã•ã‚Œã¾ã™ã€‚setã®è¡¨ç¾ã¯é–¢é€£ãƒ¢ãƒ‡ãƒ«ã§ã¯ã‚‚ã£ã¨ã‚‚自然ã ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr "ã—ã‹ã—ã€ã‚ˆãデザインã•ã‚ŒãŸHibernateã®ãƒ‰ãƒ¡ã‚¤ãƒ³ãƒ¢ãƒ‡ãƒ«ã§ã¯ã€é€šå¸¸ã‚‚ã£ã¨ã‚‚多ã„コレクション㯠事実上 <literal>inverse=\"true\"</literal> を指定ã—ãŸ1対多関連ã§ã™ã€‚ã“れらã®é–¢é€£ã§ã¯ã€ æ›´æ–°ã¯å¤šå¯¾ä¸€ã®é–¢é€£ç«¯ã§æ‰±ã‚ã‚Œã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®æ›´æ–°ãƒ‘フォーマンスã®å•é¡Œã¯å½“ã¦ã¯ã¾ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr "inverseコレクションã«ã‚‚ã£ã¨ã‚‚最é©ãªbagã¨list"
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr "bagを見放ã—ã¦ã—ã¾ã†å‰ã«ã€bag（ãã—ã¦listも）ãŒsetよりもãšã£ã¨ãƒ‘フォーマンスãŒè‰¯ã„特別ãªã‚±ãƒ¼ã‚¹ã‚’ 紹介ã—ã¾ã™ã€‚ <literal>inverse=\"true\"</literal> ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆä¸€èˆ¬çš„ãª1対多関連ã®ä½¿ã„æ–¹ãªã©ï¼‰ã§ã€ bagã®è¦ç´ ã‚’åˆæœŸåŒ–（フェッãƒï¼‰ã™ã‚‹å¿…è¦ãªãbagã‚„listã«è¦ç´ ã‚’è¿½åŠ ã§ãã¾ã™ï¼ ã“れ㯠<literal>Collection.add()</literal> ã‚„ <literal>Collection.addAll()</literal> ã¯bagã‚„ <literal>List</literal> ã§ã¯å¸¸ã«trueã‚’è¿”ã•ãªã‘ã‚Œã°ãªã‚‰ãªã„ã‹ã‚‰ã§ã™ （ <literal>Set</literal> ã¨ã¯ç•°ãªã‚Šã¾ã™ï¼‰ã€‚ ã“ã‚Œã¯ä»¥ä¸‹ã®å…±é€šå‡¦ç†ã‚’より速ãã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);
+\n"
+ "Child c = new Child();
+\n"
+ "c.setParent(p);
+\n"
+ "p.getChildren().add(c); //no need to fetch the collection!
+\n"
+ "sess.flush();]]>"
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr "一括削除"
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr "時々ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ を一ã¤ä¸€ã¤å‰Šé™¤ã™ã‚‹ã“ã¨ã¯æ¥µã‚ã¦éžåŠ¹çŽ‡çš„ã«ãªã‚‹ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ Hibernateã¯æ„šã‹ã§ã¯ãªã„ã®ã§ã€æ–°ã—ã„空ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å ´åˆï¼ˆ <literal>list.clear()</literal> を呼ã³å‡ºã—ãŸå ´åˆãªã©ï¼‰ã§ã¯ã“れをã™ã¹ãã§ãªã„ã“ã¨ã‚’知ã£ã¦ã„ã¾ã™ã€‚ã“ã®å ´åˆã¯ã€Hibernate㯠<literal>DELETE</literal> を一回発行ã—ã¦ã€ãã‚Œã§ã™ã¹ã¦çµ‚ã‚ã‚Šã¾ã™ï¼"
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr "サイズ20ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ä¸€ã¤ã®è¦ç´ ã‚’è¿½åŠ ã—ã€ãã‚Œã‹ã‚‰äºŒã¤ã®è¦ç´ を削除ã™ã‚‹ã¨ã—ã¾ã™ã€‚ Hibernateã¯ä¸€ã¤ã® <literal>INSERT</literal> æ–‡ã¨äºŒã¤ã® <literal>DELETE</literal> 文を発行ã—ã¾ã™ （コレクションãŒbagã§ãªã‘ã‚Œã°ï¼‰ã€‚ã“ã‚Œã¯ç¢ºã‹ã«æœ›ã¾ã—ã„動作ã§ã™ã€‚"
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr "ã—ã‹ã—ã€18個ã®è¦ç´ を削除ã—ã¦2ã¤ã‚’残ã—ã€ãã‚Œã‹ã‚‰3ã¤æ–°ã—ã„è¦ç´ ã‚’è¿½åŠ ã™ã‚‹ã¨ã—ã¾ã™ã€‚ ã“ã®ã¨ã二ã¤ã®æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr "18行を一ã¤ä¸€ã¤å‰Šé™¤ã—ã¦ã€3è¡Œã‚’è¿½åŠ ã™ã‚‹"
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr "コレクション全体を削除（ <literal>DELETE</literal> ã®SQLを一回）ã—ã€ãã—ã¦5ã¤ã®è¦ç´ ã™ã¹ã¦ã‚’ （一ã¤ãšã¤ï¼‰è¿½åŠ ã™ã‚‹"
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr "Hibernateã¯ã“ã®å ´åˆã«2番目ã®æ–¹æ³•ãŒã‚ˆã‚Šé€Ÿã„ã ã‚ã†ã¨ã‚ã‹ã‚‹ã»ã©è³¢ãã¯ã‚ã‚Šã¾ã›ã‚“。 （ãã—ã¦HibernateãŒã“ã®ã‚ˆã†ã«è³¢ã„ã“ã¨ã‚‚望ã¾ã—ããªã„ã§ã—ょã†ã€‚ã“ã®ã‚ˆã†ãªæŒ¯ã‚‹èˆžã„㯠データベースã®ãƒˆãƒªã‚¬ãªã©ã‚’æ··ä¹±ã•ã›ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。）"
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr "幸ã„ã«ã‚‚ã€å…ƒã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’æ¨ã¦ï¼ˆã¤ã¾ã‚Šå‚照をやã‚ã¦ï¼‰ã€ç¾åœ¨ã®è¦ç´ ã‚’ã™ã¹ã¦æŒã¤æ–°ã—ã„コレクション㮠インスタンスを返ã™ã“ã¨ã§ã€ã„ã¤ã§ã‚‚ã“ã®æŒ¯ã‚‹èˆžã„（2番目ã®æˆ¦ç•¥ï¼‰ã‚’強制ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ 時ã«ã“ã‚Œã¯ã¨ã¦ã‚‚便利ã§å¼·åŠ›ã§ã™ã€‚"
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr "ã‚‚ã¡ã‚ã‚“ã€ä¸€æ‹¬å‰Šé™¤ã¯ <literal>inverse=\"true\"</literal> を指定ã—ãŸã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã¯è¡Œã„ã¾ã›ã‚“。"
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr "パフォーマンスã®ãƒ¢ãƒ‹ã‚¿ãƒªãƒ³ã‚°"
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr "最é©åŒ–ã¯ãƒ¢ãƒ‹ã‚¿ãƒªãƒ³ã‚°ã‚„パフォーマンスを示ã™æ•°å€¤ãŒãªã‘ã‚Œã°å分ã«è¡Œãˆã¾ã›ã‚“。 Hibernateã¯å†…部処ç†ã®ã™ã¹ã¦ã®ç¯„囲ã®æ•°å€¤ã‚’æä¾›ã—ã¾ã™ã€‚ Hibernateã®çµ±è¨ˆæƒ…å ±ã¯ <literal>SessionFactory</literal> å˜ä½ã§å–å¾—å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr "SessionFactoryã®ãƒ¢ãƒ‹ã‚¿ãƒªãƒ³ã‚°"
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr "<literal>SessionFactory</literal> ã®ãƒ¡ãƒˆãƒªã‚¯ã‚¹ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã«ã¯2ã¤ã®æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚ 最åˆã®æ–¹æ³•ã¯ã€ <literal>sessionFactory.getStatistics()</literal> を呼ã³å‡ºã—〠自分㧠<literal>Statistics</literal> ã®èªã¿è¾¼ã¿ã‚„表示を行ã„ã¾ã™ã€‚"
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr "<literal>StatisticsService</literal> MBeanを有効ã«ã—ã¦ã„ã‚Œã°ã€Hibernateã¯JMXを使ã£ã¦ メトリクスを発行ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚1ã¤ã®MBeanã‚’ã™ã¹ã¦ã® <literal>SessionFactory</literal> ã«å¯¾ã—ã¦æœ‰åŠ¹ã«ã™ã‚‹ã‹ã€SessionFactoryã”ã¨ã«ä¸€ã¤ã®MBeanを有効ã«ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ 最å°é™ã®è¨å®šä¾‹ã§ã‚る以下ã®ã‚³ãƒ¼ãƒ‰ã‚’見ã¦ãã ã•ã„。"
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory
+\n"
+ "Hashtable tb = new Hashtable();
+\n"
+ "tb.put(\"type\", \"statistics\");
+\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");
+\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name
+\n"
+ "
+\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation
+\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory
+\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr ""
+ "<![CDATA[// MBean service registration for all SessionFactory's
+\n"
+ "Hashtable tb = new Hashtable();
+\n"
+ "tb.put(\"type\", \"statistics\");
+\n"
+ "tb.put(\"sessionFactory\", \"all\");
+\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name
+\n"
+ "
+\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation
+\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr "TODO: ã“ã‚Œã¯æ„味ãŒã‚ã‚Šã¾ã›ã‚“。最åˆã®ã‚±ãƒ¼ã‚¹ã¯ã€MBeanを直接復元ã—ã¦ä½¿ç”¨ã—ã¾ã™ã€‚2番目ã®ã‚±ãƒ¼ã‚¹ã¯ã€ 使ã†å‰ã«session factoryãŒæŒã£ã¦ã„ã‚‹JNDIåを渡ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal> を使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr "<literal>SessionFactory</literal> ã«å¯¾ã—ã¦ãƒ¢ãƒ‹ã‚¿ãƒªãƒ³ã‚°ã®é–‹å§‹ï¼ˆçµ‚了）を行ã†ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr "è¨å®šæ™‚ã«ã¯ã€ <literal>hibernate.generate_statistics</literal> ã‚’ <literal>false</literal> ã«ã—ã¾ã™"
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr "実行時ã«ã€ <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> ã¾ãŸã¯ <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal> を呼ã³å‡ºã—ã¾ã™"
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr "統計㯠<literal>clear()</literal> メソッドを使ã£ã¦æ‰‹å‹•ã§ãƒªã‚»ãƒƒãƒˆã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ サマリ㯠<literal>logSummary()</literal> メソッドを使ã£ã¦loggerã«é€ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ （infoレベルã§ã™ï¼‰ã€‚"
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr "メトリクス"
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr "多ãã®ã‚‚ã®ãŒã‚ã‚Šã¾ã™ã€‚ã™ã¹ã¦ã®ä½¿ç”¨å¯èƒ½ãªã‚«ã‚¦ãƒ³ã‚¿ã¯ <literal>Statistics</literal> インターフェイスã®APIã«æ›¸ã‹ã‚Œã¦ãŠã‚Šã€3ã¤ã®åˆ†é¡žãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr "メトリクスã¯ä¸€èˆ¬çš„㪠<literal>Session</literal> ã®ä½¿ã„æ–¹ã¨é–¢ä¿‚ã—ã¦ã„ã¾ã™ã€‚ オープンã—ãŸã‚»ãƒƒã‚·ãƒ§ãƒ³ã®æ•°ãŒJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã¨é–¢é€£ã—ã¦ã„ã‚‹ã®ã¨åŒã˜ã§ã™ã€‚"
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr "メトリクスã¯è¦ç´ ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚¯ã‚¨ãƒªã‚„ã‚ャッシュãªã©å…¨ä½“㫠関係ã—ã¦ã„ã¾ã™ï¼ˆåˆ¥åã¯ã‚°ãƒãƒ¼ãƒãƒ«ãƒ¡ãƒˆãƒªã‚¯ã‚¹ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr "メトリクスã®è©³ç´°ã¯ç‰¹å®šã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚¯ã‚¨ãƒªã€ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã«é–¢ä¿‚ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr "例ã¨ã—ã¦ã€ã‚ャッシュã®ãƒ’ットã€ãƒ’ットミスやã€è¦ç´ ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚¯ã‚¨ãƒªã®å‰²åˆã€ã‚¯ã‚¨ãƒªã®å®Ÿè¡Œã« å¿…è¦ãªå¹³å‡æ™‚間を確èªã§ãã¾ã™ã€‚ミリ秒ã®æ•°å€¤ã¯Javaã®è¿‘似をå—ã‘ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 Hibernateã¯JVMã®ç²¾åº¦ã«åˆ¶é™ã•ã‚Œã€ãƒ—ラットフォームã«ã‚ˆã£ã¦ã¯10秒å˜ä½ã§ã—ã‹æ£ç¢ºã§ãªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr "å˜ç´”ãªgetterã¯ã‚°ãƒãƒ¼ãƒãƒ«ãƒ¡ãƒˆãƒªã‚¯ã‚¹ï¼ˆã™ãªã‚ã¡ç‰¹å®šã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸãªã©ã«ç¸›ã‚‰ã‚Œãªã„） ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã«ä½¿ã„ã¾ã™ã€‚特定ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã®ãƒ¡ãƒˆãƒªã‚¯ã‚¹ã¯ã€ ãれらã®åå‰ã‚„ã€ã‚¯ã‚¨ãƒªã®HQLã€SQL表ç¾ã«ã‚ˆã£ã¦ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ã•ã‚‰ã«è©³ã—ã„æƒ…å ±ã¯ã€ <literal>Statistics</literal> 〠<literal>EntityStatistics</literal> 〠<literal>CollectionStatistics</literal> 〠<literal>SecondLevelCacheStatistics</literal> 〠<literal>QueryStatistics</literal> APIã®javadocã‚’ å‚ç…§ã—ã¦ãã ã•ã„。以下ã®ã‚³ãƒ¼ãƒ‰ã¯ç°¡å˜ãªä¾‹ã§ã™ã€‚"
+
+#: index.docbook:1352
+msgid "appended paragraph 1"
+msgstr ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();
+\n"
+ "
+\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();
+\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();
+\n"
+ "double queryCacheHitRatio =
+\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);
+\n"
+ "
+\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);
+\n"
+ "
+\n"
+ "EntityStatistics entityStats =
+\n"
+ " stats.getEntityStatistics( Cat.class.getName() );
+\n"
+ "long changes =
+\n"
+ " entityStats.getInsertCount()
+\n"
+ " + entityStats.getUpdateCount()
+\n"
+ " + entityStats.getDeleteCount();
+\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+
+#: index.docbook:1369
+msgid "appended paragraph 2"
+msgstr "ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€ã‚¯ã‚¨ãƒªã€ã‚ãƒ£ãƒƒã‚·ãƒ¥é ˜åŸŸã«å¯¾ã—ã¦è¡Œã†å ´åˆã¯ã€ <literal>getQueries()</literal> 〠<literal>getEntityNames()</literal>〠<literal>getCollectionRoleNames()</literal> 〠<literal>getSecondLevelCacheRegionNames()</literal> メソッド㧠ãã‚Œãžã‚Œã®åå‰ã®ãƒªã‚¹ãƒˆã‚’å–å¾—ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,867 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr "永続クラス"
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr "永続クラスã¯ãƒ“ジãƒã‚¹ä¸Šã®å•é¡Œã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ï¼ˆä¾‹ãˆã°ã€Eコマースアプリケーションã®é¡§å®¢ã‚„注文） を実装ã™ã‚‹ã‚¢ãƒ—リケーションã®ã‚¯ãƒ©ã‚¹ã§ã™ã€‚ 永続クラスã®ã™ã¹ã¦ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒæ°¸ç¶šçŠ¶æ…‹ã§ã‚ã‚‹ã¨è¦‹ãªã•ã‚Œã‚‹ã‚ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 インスタンスã¯é€†ã«ä¸€æ™‚的（transient）ã§ã‚ã£ãŸã‚Šã€åˆ†é›¢çŠ¶æ…‹ï¼ˆdetached）ã§ã‚ã£ãŸã‚Šã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr "Plain Old Java Object (POJO)プãƒã‚°ãƒ©ãƒŸãƒ³ã‚°ãƒ¢ãƒ‡ãƒ«ã¨ã—ã¦ã‚‚知られる ã„ãã¤ã‹ã®å˜ç´”ãªãƒ«ãƒ¼ãƒ«ã«å¾“ã†ãªã‚‰ã€Hibernateã¯æœ€ã‚‚よãåƒãã¾ã™ã€‚ ã—ã‹ã—ã“れらã®ãƒ«ãƒ¼ãƒ«ã¯é›£ã—ã„ã‚‚ã®ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 実際Hibernate3ã¯æ°¸ç¶šã‚ªãƒ–ジェクトã®æ€§è³ªã«ã»ã¨ã‚“ã©ä½•ã®å‰æã‚‚ç½®ã„ã¦ã„ã¾ã›ã‚“。 ドメインモデルã¯ä»–ã®æ–¹æ³•ã§è¡¨ç¾ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ 例ãˆã° <literal>Map</literal> インスタンスã®ãƒ„リーを使ã†æ–¹æ³•ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr "å˜ç´”ãªPOJOã®ä¾‹"
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr "ã»ã¨ã‚“ã©ã®Javaアプリケーションã«ã¯ãƒã‚³ç§‘ã®å‹•ç‰©ã‚’表ç¾ã™ã‚‹æ°¸ç¶šã‚¯ãƒ©ã‚¹ãŒå¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "import java.util.Set;
+\n"
+ "import java.util.Date;
+\n"
+ "
+\n"
+ "public class Cat {
+\n"
+ " private Long id; // identifier
+\n"
+ "
+\n"
+ " private Date birthdate;
+\n"
+ " private Color color;
+\n"
+ " private char sex;
+\n"
+ " private float weight;
+\n"
+ " private int litterId;
+\n"
+ "
+\n"
+ " private Cat mother;
+\n"
+ " private Set kittens = new HashSet();
+\n"
+ "
+\n"
+ " private void setId(Long id) {
+\n"
+ " this.id=id;
+\n"
+ " }
+\n"
+ " public Long getId() {
+\n"
+ " return id;
+\n"
+ " }
+\n"
+ "
+\n"
+ " void setBirthdate(Date date) {
+\n"
+ " birthdate = date;
+\n"
+ " }
+\n"
+ " public Date getBirthdate() {
+\n"
+ " return birthdate;
+\n"
+ " }
+\n"
+ "
+\n"
+ " void setWeight(float weight) {
+\n"
+ " this.weight = weight;
+\n"
+ " }
+\n"
+ " public float getWeight() {
+\n"
+ " return weight;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public Color getColor() {
+\n"
+ " return color;
+\n"
+ " }
+\n"
+ " void setColor(Color color) {
+\n"
+ " this.color = color;
+\n"
+ " }
+\n"
+ "
+\n"
+ " void setSex(char sex) {
+\n"
+ " this.sex=sex;
+\n"
+ " }
+\n"
+ " public char getSex() {
+\n"
+ " return sex;
+\n"
+ " }
+\n"
+ "
+\n"
+ " void setLitterId(int id) {
+\n"
+ " this.litterId = id;
+\n"
+ " }
+\n"
+ " public int getLitterId() {
+\n"
+ " return litterId;
+\n"
+ " }
+\n"
+ "
+\n"
+ " void setMother(Cat mother) {
+\n"
+ " this.mother = mother;
+\n"
+ " }
+\n"
+ " public Cat getMother() {
+\n"
+ " return mother;
+\n"
+ " }
+\n"
+ " void setKittens(Set kittens) {
+\n"
+ " this.kittens = kittens;
+\n"
+ " }
+\n"
+ " public Set getKittens() {
+\n"
+ " return kittens;
+\n"
+ " }
+\n"
+ "
+\n"
+ " // addKitten not needed by Hibernate
+\n"
+ " public void addKitten(Cat kitten) {
+\n"
+ " kitten.setMother(this);
+\n"
+ " kitten.setLitterId( kittens.size() );
+\n"
+ " kittens.add(kitten);
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr "従ã†ã¹ã4ã¤ã®ãƒ«ãƒ¼ãƒ«ãŒã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr "引数ã®ãªã„コンストラクタを実装ã™ã‚‹"
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr "<literal>Cat</literal> ã«ã¯å¼•æ•°ã®ãªã„コンストラクタãŒã‚ã‚Šã¾ã™ã€‚ Hibernate㌠<literal>Constructor.newInstance()</literal> を使ã£ã¦æ°¸ç¶šã‚¯ãƒ©ã‚¹ã® インスタンス化を行ãˆã‚‹ã‚ˆã†ã«ã€ã™ã¹ã¦ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã«ã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ （publicã§ãªãã¦ã‚‚構ã„ã¾ã›ã‚“）ãŒãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 Hibernateã®å®Ÿè¡Œæ™‚プãƒã‚シ生æˆã®ãŸã‚ã«ã€å°‘ãªãã¨ã‚‚ <emphasis>package</emphasis> ã®å¯è¦–性をæŒã¤ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ã‚’å¼·ããŠå‹§ã‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr "è˜åˆ¥åプãƒãƒ‘ティを用æ„ã™ã‚‹ï¼ˆã‚ªãƒ—ション）"
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr "<literal>Cat</literal> ã«ã¯ <literal>id</literal> ã¨ã„ã†ãƒ—ãƒãƒ‘ティãŒã‚ã‚Šã¾ã™ã€‚ ã“ã®ãƒ—ãƒãƒ‘ティã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルã®ä¸»ã‚ーカラムã¸ãƒžãƒƒãƒ”ングã•ã‚Œã¾ã™ã€‚ ã“ã®ãƒ—ãƒãƒ‘ティã®åå‰ã¯ä½•ã§ã‚‚構ã„ã¾ã›ã‚“ã—ã€åž‹ã¯ã©ã®ã‚ˆã†ãªãƒ—リミティブ型ã§ã‚‚〠プリミティブã®ã€Œãƒ©ãƒƒãƒ‘ーã€åž‹ã§ã‚‚ã€<literal>java.lang.String</literal> ã‚„ <literal>java.util.Date</literal> ã§ã‚‚構ã„ã¾ã›ã‚“。 （もã—レガシーデータベーステーブルãŒè¤‡åˆã‚ーをæŒã¤ãªã‚‰ã°ã€ 今述ã¹ãŸã‚ˆã†ãªåž‹ã®ãƒ—ãƒãƒ‘ティをæŒã¤ãƒ¦ãƒ¼ã‚¶å®šç¾©ã®ã‚¯ãƒ©ã‚¹ã‚’使ã†ã“ã¨ã•ãˆå¯èƒ½ã§ã™ã€‚ 後ã§è¤‡åˆè˜åˆ¥åã®ç¯€ã‚’見ã¦ãã ã•ã„。）"
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr "è˜åˆ¥åプãƒãƒ‘ティã¯åŽ³å¯†ã«ã¯ã‚ªãƒ—ションã§ã™ã€‚ ã“れをçœç•¥ã—ã¦ã€Hibernateã«å†…部的ã«ã‚ªãƒ–ジェクトã®è˜åˆ¥åを追跡ã•ã›ã‚‹ã“ã¨ã¯å¯èƒ½ã§ã™ã€‚ ã—ã‹ã—ãŠã™ã™ã‚ã¯ã—ã¾ã›ã‚“。"
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr "実際ã«ã€è˜åˆ¥åプãƒãƒ‘ティを宣言ã™ã‚‹ã‚¯ãƒ©ã‚¹ã ã‘ãŒåˆ©ç”¨å¯èƒ½ãªæ©Ÿèƒ½ãŒã„ãã¤ã‹ã‚ã‚Šã¾ã™ï¼š"
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr "分離オブジェクトã®é€£éŽ–çš„ãªå†è¿½åŠ （カスケード更新やカスケードマージ）。 <xref linkend=\"objectstate-transitive\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr "Session.saveOrUpdate()"
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr "Session.merge()"
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr "永続クラスã«ã¯ã€ä¸€è²«ã—ãŸåå‰ã®è˜åˆ¥åプãƒãƒ‘ティを定義ã™ã‚‹ã“ã¨ã‚’ãŠå‹§ã‚ã—ã¾ã™ã€‚ ã•ã‚‰ã«null値をå–れる(ã¤ã¾ã‚Šãƒ—リミティブã§ã¯ãªã„)型を使ã£ãŸæ–¹ãŒã‚ˆã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr "finalクラスã«ã—ãªã„（オプション）"
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr "Hibernateã®ä¸å¿ƒçš„ãªç‰¹å¾´ã§ã‚ã‚‹ <emphasis>プãƒã‚ã‚·</emphasis> ã¯ã€ 永続クラスãŒfinalã§ãªã„ã“ã¨ã€ã¾ãŸã¯ãƒ¡ã‚½ãƒƒãƒ‰ã‚’全部publicã§å®£è¨€ã—ã¦ã„ã‚‹ インターフェイスãŒå®Ÿè£…ã•ã‚Œã¦ã„ã‚‹ã‹ã«ä¾å˜ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr "Hibernateã§ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã—ã¦ã„ãªã„ <literal>final</literal> クラスを永続化ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã™ãŒã€ é…延関連フェッãƒã«å¯¾ã—ã¦ãƒ—ãƒã‚シを使ã†ã“ã¨ã¯ã§ããªããªã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ãƒ‘フォーマンスãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã¸ã®é¸æŠžè‚¢ã‚’ç‹ã‚ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr "finalã§ã¯ãªã„クラス㧠<literal>public final</literal> メソッドを定義ã™ã‚‹ã“ã¨ã‚‚é¿ã‘ã‚‹ã¹ãã§ã™ã€‚ <literal>public final</literal> メソッドをæŒã¤ã‚¯ãƒ©ã‚¹ã‚’使ã„ãŸã‘ã‚Œã°ã€ <literal>lazy=\"false\"</literal> ã¨è¨å®šã—ã¦æ˜Žç¤ºçš„ã«ãƒ—ãƒã‚シを無効ã«ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr "永続フィールドã«å¯¾ã™ã‚‹ã‚¢ã‚¯ã‚»ã‚µã¨ãƒŸãƒ¥ãƒ¼ãƒ†ãƒ¼ã‚¿ã‚’定義ã™ã‚‹ï¼ˆã‚ªãƒ—ション）"
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr "<literal>Cat</literal> ã§ã¯ã™ã¹ã¦ã®æ°¸ç¶šãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã«å¯¾ã—ã¦ã‚¢ã‚¯ã‚»ã‚µãƒ¡ã‚½ãƒƒãƒ‰ã‚’定義ã—ã¦ã„ã¾ã™ã€‚ ä»–ã®å¤šãã®ORMツールã¯ã€æ°¸ç¶šã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹å¤‰æ•°ã‚’直接永続化ã—ã¾ã™ã€‚ ç§ãŸã¡ã¯ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ã‚¹ã‚ーマã¨ã‚¯ãƒ©ã‚¹ã®å†…éƒ¨æ§‹é€ ã‚’åˆ†é›¢ã™ã‚‹æ–¹ãŒè‰¯ã„ã¨ä¿¡ã˜ã¦ã„ã¾ã™ã€‚ デフォルトã§ã¯ã€Hibernateã¯JavaBeanスタイルã®ãƒ—ãƒãƒ‘ティを永続化ã—〠<literal>getFoo</literal>, <literal>isFoo</literal>, <literal>setFoo</literal> å½¢å¼ã®ãƒ¡ã‚½ãƒƒãƒ‰åã‚’èªè˜ã—ã¾ã™ã€‚ ã—ã‹ã—å¿…è¦ãªã‚‰ã€ç‰¹å®šã®ãƒ—ãƒãƒ‘ティã«å¯¾ã—ã¦ã€ç›´æŽ¥ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã‚¢ã‚¯ã‚»ã‚¹ã«åˆ‡ã‚Šæ›¿ãˆã‚‹ã“ã¨ã¯å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr "プãƒãƒ‘ティã¯publicã§å®£è¨€ã™ã‚‹å¿…è¦ã¯ <emphasis>ã‚ã‚Šã¾ã›ã‚“</emphasis> 。 Hibernateã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã€<literal>protected</literal> ã‚‚ã—ã㯠<literal>private</literal> ã®get / setã®ãƒšã‚¢ã‚’æŒã¤ãƒ—ãƒãƒ‘ティを永続化ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr "継承ã®å®Ÿè£…"
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr "サブクラスも1番目ã¨2番目ã®ãƒ«ãƒ¼ãƒ«ã‚’守らãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 サブクラスã¯ã‚¹ãƒ¼ãƒ‘ークラス <literal>Cat</literal> ã‹ã‚‰è˜åˆ¥åプãƒãƒ‘ティを継承ã—ã¾ã™ã€‚"
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;
+\n"
+ "
+\n"
+ "public class DomesticCat extends Cat {
+\n"
+ " private String name;
+\n"
+ "
+\n"
+ " public String getName() {
+\n"
+ " return name;
+\n"
+ " }
+\n"
+ " protected void setName(String name) {
+\n"
+ " this.name=name;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr "<literal>equals()</literal> 㨠<literal>hashCode()</literal> ã®å®Ÿè£…"
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr "以下ã®æ¡ä»¶ã®å ´åˆã€ <literal>equals()</literal> 㨠<literal>hashCode()</literal> メソッドをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“ã€"
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr "永続クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’ <literal>Set</literal> ã«ç½®ãå ´åˆã€‚ （ã“ã‚Œã¯å¤šå€¤ã®é–¢é€£ã‚’表ç¾ã™ã‚‹ãŠã™ã™ã‚ã®æ–¹æ³•ã§ã™ï¼‰ <emphasis>ãã—ã¦åŒæ™‚ã«</emphasis>"
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr "分離インスタンスをセッションã¸å†è¿½åŠ ã™ã‚‹å ´åˆã€‚"
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr "Hibernateã¯ã€æ°¸ç¶šID（データベースã®è¡Œï¼‰ã¨ã€ç‰¹å®šã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚¹ã‚³ãƒ¼ãƒ—内㫠é™å®šã§ã™ãŒJavaIDã¨ãŒç‰ä¾¡ã§ã‚ã‚‹ã“ã¨ã‚’ä¿è¨¼ã—ã¾ã™ã€‚ ã§ã™ã‹ã‚‰ç•°ãªã‚‹ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§æ¤œç´¢ã—ãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’組ã¿åˆã‚ã›ã‚‹å ´åˆã€ <literal>Set</literal> ã«æ„味ã®ã‚るセマンティクスをæŒãŸã›ã‚ˆã†ã¨æ€ã£ã¦ã„ã‚‹ãªã‚‰ ã™ãã«<literal>equals()</literal> 㨠<literal>hashCode()</literal> を実装ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr "最も明白ãªæ–¹æ³•ã¯ã€ä¸¡æ–¹ã®ã‚ªãƒ–ジェクトã®è˜åˆ¥åã®å€¤ã®æ¯”較ã«ã‚ˆã£ã¦ <literal>equals()</literal>㨠<literal>hashCode()</literal> を実装ã™ã‚‹æ–¹æ³•ã§ã™ã€‚ 値ãŒåŒã˜ãªã‚‰ã€ä¸¡è€…ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®åŒã˜è¡Œã§ãªã‘ã‚Œã°ãªã‚‰ãªã„ãŸã‚ç‰ã—ããªã‚Šã¾ã™ã€‚ （両者㌠<literal>Set</literal> ã«è¿½åŠ ã•ã‚Œã¦ã‚‚〠<literal>Set</literal> ã«ã¯1個ã®è¦ç´ ã—ã‹ãªã„ã“ã¨ã«ãªã‚Šã¾ã™ï¼‰ 残念ãªã“ã¨ã«ã€ç”Ÿæˆã•ã‚ŒãŸè˜åˆ¥åã«ã¯ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’使ã†ã“ã¨ãŒã§ãã¾ã›ã‚“。 Hibernateã¯æ°¸ç¶šåŒ–ã•ã‚ŒãŸã‚ªãƒ–ジェクトã¸è˜åˆ¥åã®å€¤ã‚’代入ã™ã‚‹ã ã‘ã§ã‚り〠新ã—ã作æˆã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã©ã®ã‚ˆã†ãªè˜åˆ¥åã®å€¤ã‚‚æŒã£ã¦ã„ã¾ã›ã‚“。 ã•ã‚‰ã«ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã‚»ãƒ¼ãƒ–ã•ã‚Œã¦ãŠã‚‰ãšã€ç¾åœ¨ <literal>Set</literal> ã®ä¸ã«ã‚ã‚Œã°ã€ セーブã™ã‚‹ã¨ã‚ªãƒ–ジェクトã¸è˜åˆ¥åã®å€¤ã‚’代入ã™ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ ã‚‚ã— <literal!
>equals()</literal> 㨠<literal>hashCode()</literal> ãŒè˜åˆ¥åã®å€¤ã«åŸºã¥ã„ã¦ã„ã‚‹ãªã‚‰ã€ ãƒãƒƒã‚·ãƒ¥ã‚³ãƒ¼ãƒ‰ãŒå¤‰æ›´ã•ã‚Œã‚‹ã¨ <literal>Set</literal> ã®è¦ç´„ãŒç ´ã‚‰ã‚Œã¾ã™ã€‚ ã“ã®å•é¡Œã«ã¤ã„ã¦ã®å®Œå…¨ãªè°è«–ã¯ã€Hibernateã®ã‚¦ã‚§ãƒ–サイトを見ã¦ãã ã•ã„。 ã“ã‚Œã¯Hibernateã®å•é¡Œã§ã¯ãªãã€ã‚ªãƒ–ジェクトã®åŒä¸€æ€§ã¨ç‰ä¾¡æ€§ã«ã¤ã„ã¦ã®ã€ 通常ã®Javaã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr "<emphasis>ビジãƒã‚¹ã‚ーã®ç‰ä¾¡æ€§</emphasis> を使ã£ã¦ã€ <literal>equals()</literal> 㨠<literal>hashCode()</literal> を実装ã™ã‚‹ã“ã¨ã‚’ãŠå‹§ã‚ã—ã¾ã™ã€‚ ビジãƒã‚¹ã‚ーã®ç‰ä¾¡æ€§ã¨ã¯ã€<literal>equals()</literal> メソッドãŒã€ãƒ“ジãƒã‚¹ã‚ー〠ã¤ã¾ã‚Šç¾å®Ÿã®ä¸–ç•Œã«ãŠã„ã¦ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’特定ã™ã‚‹ã‚ー（<emphasis>自然</emphasis> 候補ã‚ー） ã‚’å½¢æˆã™ã‚‹ãƒ—ãƒãƒ‘ティã ã‘を比較ã™ã‚‹ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Cat {
+\n"
+ "
+\n"
+ " ...
+\n"
+ " public boolean equals(Object other) {
+\n"
+ " if (this == other) return true;
+\n"
+ " if ( !(other instanceof Cat) ) return false;
+\n"
+ "
+\n"
+ " final Cat cat = (Cat) other;
+\n"
+ "
+\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;
+\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;
+\n"
+ "
+\n"
+ " return true;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public int hashCode() {
+\n"
+ " int result;
+\n"
+ " result = getMother().hashCode();
+\n"
+ " result = 29 * result + getLitterId();
+\n"
+ " return result;
+\n"
+ " }
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr "ビジãƒã‚¹ã‚ーã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ä¸»ã‚ー候補ã»ã©å®‰å®šã§ã‚ã‚‹å¿…è¦ã¯ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„ （<xref linkend=\"transactions-basics-identity\"/> を見ã¦ãã ã•ã„）。 æ›´æ–°ä¸å¯ãªãƒ—ãƒãƒ‘ティやユニークãªãƒ—ãƒãƒ‘ティã¯ã€é€šå¸¸ãƒ“ジãƒã‚¹ã‚ーã®ã‚ˆã„候補ã§ã™ã€‚"
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr "動的モデル"
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr "以下ã®æ©Ÿèƒ½ã¯ç¾åœ¨å®Ÿé¨“段階ã«ã‚ã‚‹ã¨è¦‹ãªã•ã‚Œã¦ãŠã‚Šã€ è¿‘ã„å°†æ¥å¤‰æ›´ã•ã‚Œã‚‹å¯èƒ½æ€§ãŒã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr "永続エンティティã¯ã€å¿…ãšã—も実行時ã«POJOクラスやJavaBeanオブジェクトã§è¡¨ç¾ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 Hibernateã¯ï¼ˆå®Ÿè¡Œæ™‚ã« <literal>Map</literal> ã® <literal>Map</literal> を使ã†ï¼‰å‹•çš„モデルã¨ã€ DOM4Jツリーã¨ã—ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®è¡¨ç¾ã‚‚サãƒãƒ¼ãƒˆã—ã¾ã™ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’使ã†ã¨æ°¸ç¶šã‚¯ãƒ©ã‚¹ã‚’書ã‹ãšã€ãƒžãƒƒãƒ”ングファイルã ã‘を書ãã“ã¨ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr "デフォルトã§ã¯ã€Hibernateã¯é€šå¸¸ã®POJOモードã§å‹•ä½œã—ã¾ã™ã€‚ <literal>default_entity_mode</literal> è¨å®šã‚ªãƒ—ションを使ã£ã¦ã€ 特定㮠<literal>SessionFactory</literal> ã«å¯¾ã™ã‚‹ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£è¡¨ç¾ãƒ¢ãƒ¼ãƒ‰ã‚’è¨å®šã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ （<xref linkend=\"configuration-optional-properties\"/> を見ã¦ãã ã•ã„）。"
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr "以下ã®ä¾‹ã§ã¯ <literal>Map</literal> を使ã£ãŸè¡¨ç¾ã‚’紹介ã—ã¾ã™ã€‚ ã¾ãšãƒžãƒƒãƒ”ングファイルã§ã€ã‚¯ãƒ©ã‚¹åã®ä»£ã‚ã‚Šã«ï¼ˆã¾ãŸã¯ãã‚Œã«åŠ ãˆã¦ï¼‰ <literal>entity-name</literal> を定義ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“："
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class entity-name=\"Customer\">
+\n"
+ "
+\n"
+ " <id name=\"id\"
+\n"
+ " type=\"long\"
+\n"
+ " column=\"ID\">
+\n"
+ " <generator class=\"sequence\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <property name=\"name\"
+\n"
+ " column=\"NAME\"
+\n"
+ " type=\"string\"/>
+\n"
+ "
+\n"
+ " <property name=\"address\"
+\n"
+ " column=\"ADDRESS\"
+\n"
+ " type=\"string\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"organization\"
+\n"
+ " column=\"ORGANIZATION_ID\"
+\n"
+ " class=\"Organization\"/>
+\n"
+ "
+\n"
+ " <bag name=\"orders\"
+\n"
+ " inverse=\"true\"
+\n"
+ " lazy=\"false\"
+\n"
+ " cascade=\"all\">
+\n"
+ " <key column=\"CUSTOMER_ID\"/>
+\n"
+ " <one-to-many class=\"Order\"/>
+\n"
+ " </bag>
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr "関連ãŒã‚¿ãƒ¼ã‚²ãƒƒãƒˆã®ã‚¯ãƒ©ã‚¹åを使ã£ã¦å®šç¾©ã—ã¦ã„ãŸã¨ã—ã¦ã‚‚〠関連ã®ã‚¿ãƒ¼ã‚²ãƒƒãƒˆåž‹ã‚‚POJOã§ã¯ãªãå‹•çš„ãªã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã§ã‚‚構ã‚ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr "<literal>SessionFactory</literal> ã«å¯¾ã—ã¦ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒ¢ãƒ¼ãƒ‰ã‚’ <literal>dynamic-map</literal> ã«è¨å®šã—ãŸå¾Œã€ 実行時㫠<literal>Map</literal> ã® <literal>Map</literal> を使ã†ã“ã¨ãŒã§ãã¾ã™ï¼š"
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr ""
+ "<![CDATA[Session s = openSession();
+\n"
+ "Transaction tx = s.beginTransaction();
+\n"
+ "Session s = openSession();
+\n"
+ "
+\n"
+ "// Create a customer
+\n"
+ "Map david = new HashMap();
+\n"
+ "david.put(\"name\", \"David\");
+\n"
+ "
+\n"
+ "// Create an organization
+\n"
+ "Map foobar = new HashMap();
+\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");
+\n"
+ "
+\n"
+ "// Link both
+\n"
+ "david.put(\"organization\", foobar);
+\n"
+ "
+\n"
+ "// Save both
+\n"
+ "s.save(\"Customer\", david);
+\n"
+ "s.save(\"Organization\", foobar);
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "s.close();]]>"
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr "å‹•çš„ãªãƒžãƒƒãƒ”ングã®åˆ©ç‚¹ã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ã®å®Ÿè£…ã‚’å¿…è¦ã¨ã—ãªã„ãŸã‚〠プãƒãƒˆã‚¿ã‚¤ãƒ”ングã«è¦ã™ã‚‹ã‚¿ãƒ¼ãƒ³ã‚¢ãƒ©ã‚¦ãƒ³ãƒ‰ã‚¿ã‚¤ãƒ ãŒæ—©ã„ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ã—ã‹ã—コンパイル時ã®åž‹ãƒã‚§ãƒƒã‚¯ãŒãªã„ã®ã§ã€å®Ÿè¡Œæ™‚ã«éžå¸¸ã«å¤šãã®ä¾‹å¤–処ç†ã‚’扱ã‚ãªã‘ã‚Œã°ãªã‚‰ãªã„ã§ã—ょã†ã€‚ Hibernateマッピングã®ãŠã‹ã’ã§ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã¯å®¹æ˜“ã«æ£è¦åŒ–ã§ãã€å¥å…¨ã«ãªã‚Šã€ 後ã§é©åˆ‡ãªãƒ‰ãƒ¡ã‚¤ãƒ³ãƒ¢ãƒ‡ãƒ«ã®å®Ÿè£…ã‚’è¿½åŠ ã™ã‚‹ã“ã¨ãŒå¯èƒ½ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr "エンティティ表ç¾ãƒ¢ãƒ¼ãƒ‰ã¯ <literal>Session</literal> ã”ã¨ã«è¨å®šã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);
+\n"
+ "
+\n"
+ "// Create a customer
+\n"
+ "Map david = new HashMap();
+\n"
+ "david.put(\"name\", \"David\");
+\n"
+ "dynamicSession.save(\"Customer\", david);
+\n"
+ "...
+\n"
+ "dynamicSession.flush();
+\n"
+ "dynamicSession.close()
+\n"
+ "...
+\n"
+ "// Continue on pojoSession
+\n"
+ "]]>"
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr "<literal>EntityMode</literal> を使ã£ãŸ <literal>getSession()</literal> ã®å‘¼ã³å‡ºã—㯠<literal>SessionFactory</literal> ã§ã¯ãªã <literal>Session</literal> APIã«ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ãã®æ–¹æ³•ã§ã¯ã€æ–°ã—ã„ <literal>Session</literal> ã¯ã€ãƒ™ãƒ¼ã‚¹ã¨ãªã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã€ トランザクションã€ãã®ä»–ã®ã‚³ãƒ³ãƒ†ã‚ã‚¹ãƒˆæƒ…å ±ã‚’å…±æœ‰ã—ã¾ã™ã€‚ ã“ã‚Œã¯2番目㮠<literal>Session</literal> ã§ã¯ <literal>flush()</literal> 㨠<literal>close()</literal> を呼ã¶å¿…è¦ãŒãªã„ã¨ã„ã†ã“ã¨ã€ãã®ãŸã‚トランザクションã¨ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã®ç®¡ç†ã‚’ 1番目ã®ä½œæ¥å˜ä½(Unit of Work)ã«ä»»ã›ã‚‹ã“ã¨ãŒã§ãã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr "XML表ç¾ã®èƒ½åŠ›ã«ã¤ã„ã¦ã®ã•ã‚‰ãªã‚‹æƒ…å ±ã¯ <xref linkend=\"xml\"/> ã§è¦‹ã¤ã‹ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr "Tuplizer"
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr "<literal>org.hibernate.tuple.Tuplizer</literal> ã¨ãã®ã‚µãƒ–インターフェイスã¯ã€ 表ç¾ã® <literal>org.hibernate.EntityMode</literal> を利用ã—ã¦ã€ データæ–片ã®ã‚る表ç¾ã®ç®¡ç†ã«è²¬ä»»ã‚’æŒã¡ã¾ã™ã€‚ 与ãˆã‚‰ã‚ŒãŸãƒ‡ãƒ¼ã‚¿æ–ç‰‡ã‚’ãƒ‡ãƒ¼ã‚¿æ§‹é€ ã¨ã—ã¦è€ƒãˆã‚‹ãªã‚‰ã€Tuplizerã¯ãã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿æ§‹é€ ã‚’ ã©ã®ã‚ˆã†ã«ä½œæˆã™ã‚‹ã‹ã‚’知りã€ãã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿æ§‹é€ ã‹ã‚‰ã©ã®ã‚ˆã†ã«å€¤ã‚’抽出ã—〠注入ã™ã‚‹ã‹ã‚’知ã£ã¦ã„ã¾ã™ã€‚ 例ãˆã°POJOエンティティモードã§ã¯ã€å¯¾å¿œã™ã‚‹Tuplizerã¯ã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ã‚’通ã—ã¦ã€ POJOã‚’ã©ã®ã‚ˆã†ã«ä½œæˆã™ã‚‹ã‹ã€å®šç¾©ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティアクセサを使ã„〠POJOプãƒãƒ‘ティã«ã©ã®ã‚ˆã†ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã‹ã‚’知りã¾ã™ã€‚ Tuplizerã«ã¯äºŒã¤ã®ãƒã‚¤ãƒ¬ãƒ™ãƒ«ã®åž‹ãŒã‚ã‚Šã¾ã™ã€‚ ãれらã¯ã€<literal>org.hibernate.tuple.EntityTuplizer</literal> 㨠<literal>org.hibernate.tuple.ComponentTuplizer</literal> !
インターフェイスã§è¡¨ç¾ã•ã‚Œã¾ã™ã€‚ <literal>EntityTuplizer</literal> ã¯ä¸Šã§è¿°ã¹ãŸã‚ˆã†ãªã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«é–¢ã™ã‚‹å¥‘ç´„ã®ç®¡ç†ã«è²¬ä»»ã‚’æŒã¡ã¾ã™ã€‚ 一方ã€<literal>ComponentTuplizer</literal> ã¯ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã«é–¢ã™ã‚‹å¥‘ç´„ã®ç®¡ç†ã«è²¬ä»»ã‚’æŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr "ユーザã¯ç‹¬è‡ªã®Tuplizerã«å·®ã—替ãˆã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚ ãŠãらãdynamic-map entity-modeã®éš›ã« <literal>java.util.HashMap</literal> を使ã†ã®ã§ã¯ãªã〠<literal>java.util.Map</literal> ã®å®Ÿè£…ãŒå¿…è¦ã§ã—ょã†ã€‚ ã‚‚ã—ãã¯ã€ãŠãらãデフォルトã®ã‚‚ã®ã§ã¯ãªãã€åˆ¥ã®ãƒ—ãƒã‚シ生æˆæˆ¦ç•¥ã®å®šç¾©ãŒå¿…è¦ã§ã—ょã†ã€‚ 両者ã¨ã‚‚ã€ã‚«ã‚¹ã‚¿ãƒ ã®Tuplizer実装を定義ã™ã‚‹ã“ã¨ã§é”æˆã•ã‚Œã¾ã™ã€‚ Tuplizerã®å®šç¾©ã¯ã€ç®¡ç†ã—よã†ã¨ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„コンãƒãƒ¼ãƒãƒ³ãƒˆã®ãƒžãƒƒãƒ”ングã«çµã³ä»˜ã‘られã¾ã™ã€‚ 顧客エンティティã®ä¾‹ã«æˆ»ã‚‹ã¨ï¼š"
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ " <class entity-name=\"Customer\">
+\n"
+ " <!--
+\n"
+ " Override the dynamic-map entity-mode
+\n"
+ " tuplizer for the customer entity
+\n"
+ " -->
+\n"
+ " <tuplizer entity-mode=\"dynamic-map\"
+\n"
+ " class=\"CustomMapTuplizerImpl\"/>
+\n"
+ "
+\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">
+\n"
+ " <generator class=\"sequence\"/>
+\n"
+ " </id>
+\n"
+ "
+\n"
+ " <!-- other properties -->
+\n"
+ " ...
+\n"
+ " </class>
+\n"
+ "</hibernate-mapping>
+\n"
+ "
+\n"
+ "
+\n"
+ "public class CustomMapTuplizerImpl
+\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {
+\n"
+ " // override the buildInstantiator() method to plug in our custom map...
+\n"
+ " protected final Instantiator buildInstantiator(
+\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {
+\n"
+ " return new CustomMapInstantiator( mappingInfo );
+\n"
+ " }
+\n"
+ "
+\n"
+ " private static final class CustomMapInstantiator
+\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {
+\n"
+ " // override the generateMap() method to return our custom map...
+\n"
+ " protected final Map generateMap() {
+\n"
+ " return new CustomMap();
+\n"
+ " }
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr "TODO: プãƒãƒ‘ティã¨ãƒ—ãƒã‚シパッケージã®ãƒ¦ãƒ¼ã‚¶æ‹¡å¼µãƒ•ãƒ¬ãƒ¼ãƒ ワークを文書化ã™ã‚‹ã“ã¨"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr "<title>å‰æ›¸ã</title>"
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "今日ã®ä¼æ¥ç’°å¢ƒã«ãŠã„ã¦ã€ã‚ªãƒ–ジェクト指å‘ソフトウェアã¨ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«é–¢ã‚る作æ¥ã¯ 煩雑ã§è†¨å¤§ãªæ™‚é–“ã‚’å¿…è¦ã¨ã—ã¾ã™ã€‚ Hibernateã¯Java環境ã®ã‚ªãƒ–ジェクト/リレーショナルマッピングツールã§ã™ã€‚ オブジェクト/リレーショナルマッピング（ORM）ã¨ã¯ã€ オブジェクトモデルã‹ã‚‰SQLベーススã‚ーマã®ãƒªãƒ¬ãƒ¼ã‚·ãƒ§ãƒŠãƒ«ãƒ‡ãƒ¼ã‚¿ãƒ¢ãƒ‡ãƒ«ã¸ã¨ã€ データ表ç¾ã‚’マッピングã™ã‚‹ï¼ˆå¯¾å¿œä»˜ã‘る）技術ã®ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Hibernateã¯Javaクラスã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ†ãƒ¼ãƒ–ルã¸ï¼ˆãã—ã¦Javaデータ型ã‹ã‚‰SQLデータ型ã¸ï¼‰ ã®ãƒžãƒƒãƒ”ングを処ç†ã™ã‚‹ã ã‘ã§ã¯ãªãã€ãƒ‡ãƒ¼ã‚¿ã®ã‚¯ã‚¨ãƒªã¨å¾©å…ƒã®ä»•çµ„ã¿ã‚‚æä¾›ã—ã¾ã™ã€‚ ã“ã®ãŠã‹ã’ã§SQLã¨JDBCを使ã£ãŸæ‰‹ä½œæ¥ã§ã®ãƒ‡ãƒ¼ã‚¿å‡¦ç†ã«è²»ã‚„ã•ã‚Œã¦ã„ãŸé–‹ç™ºæ™‚間を大幅ã«å‰Šæ¸›ã§ãã¾ã™ã€‚"
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "Hibernateã®æœ€çµ‚目標ã¯ã€ãƒ‡ãƒ¼ã‚¿ã®æ°¸ç¶šåŒ–ã«é–¢ã‚る一般的ãªãƒ—ãƒã‚°ãƒ©ãƒŸãƒ³ã‚°ä½œæ¥ã®95ï¼…ã‹ã‚‰é–‹ç™ºè€…を解放ã™ã‚‹ã“ã¨ã§ã™ã€‚ Hibernateã¯ãƒ“ジãƒã‚¹ãƒã‚¸ãƒƒã‚¯ã®å®Ÿè£…ã«ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’使ㆠデータä¸å¿ƒã‚¢ãƒ—リケーションã«å¯¾ã—ã¦ã®ãƒ™ã‚¹ãƒˆã‚½ãƒªãƒ¥ãƒ¼ã‚·ãƒ§ãƒ³ã§ã‚ã‚‹ã«ç•™ã¾ã‚Šã¾ã›ã‚“。 オブジェクト指å‘ドメインモデルã¨Javaベースã®ä¸é–“層ã§ã®ãƒ“ジãƒã‚¹ãƒã‚¸ãƒƒã‚¯ã«å¯¾ã—ã¦æœ€ã‚‚å½¹ã«ç«‹ã¡ã¾ã™ã€‚ ã—ã‹ã—Hibernateã¯ãƒ™ãƒ³ãƒ€å›ºæœ‰ã®SQLコードを削減ã¾ãŸã¯ã‚«ãƒ—セル化ã—ãŸã‚Šã€ 表形å¼ã‹ã‚‰ã‚ªãƒ–ジェクトã®ã‚°ãƒ©ãƒ•ã¸ã¨ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’変æ›ã™ã‚‹ãªã©ã®ã€ 一般的ãªã‚¿ã‚¹ã‚¯ã«ã‚‚役立ã¤ã§ã—ょã†ã€‚"
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "Hibernateやオブジェクト/リレーショナルマッピング〠ã•ã‚‰ã«ã¯JavaãŒåˆã‚ã¦ã®æ–¹ã¯ã€ä»¥ä¸‹ã®ã‚¹ãƒ†ãƒƒãƒ—ã«å¾“ã£ã¦ãã ã•ã„："
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "ã‚’èªã‚“ã§ãã ã•ã„。 段階的ã«è§£èª¬ã—ã¦ã„ãã¾ã™ã€‚ ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã®ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã¯ãƒ‡ã‚£ã‚¹ãƒˆãƒªãƒ“ューション㮠<literal>doc/reference/tutorial</literal> ディレクトリã«å«ã¾ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr "ã‚’èªã‚“ã§ã€HibernateãŒåˆ©ç”¨å¯èƒ½ãªç’°å¢ƒã‚’ç†è§£ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "Hibernateディストリビューション㮠<literal>eg/</literal> ディレクトリを見ã¦ãã ã•ã„。 ç°¡å˜ãªã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ¼ãƒ³ã®ã‚¢ãƒ—リケーションãŒã‚ã‚Šã¾ã™ã€‚ JDBCドライãƒã‚’ <literal>lib/</literal> ディレクトリã«ã‚³ãƒ”ーã—ã¦ã€ 自分ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«åˆã†æ£ã—ã„値を指定ã™ã‚‹ã‚ˆã†ã« <literal>etc/hibernate.properties</literal> を編集ã—ã¦ãã ã•ã„。 ディストリビューションディレクトリã‹ã‚‰ã€ã‚³ãƒžãƒ³ãƒ‰ãƒ—ãƒãƒ³ãƒ—ト㧠<literal>ant eg</literal> ã¨ã‚¿ã‚¤ãƒ—ã—ã¦ãã ã•ã„（Antを使ã„ã¾ã™ï¼‰ã€‚ ã¾ãŸWindows環境ã§ã¯ <literal>build eg</literal> ã¨ã‚¿ã‚¤ãƒ—ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "ã“ã®ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹ãƒ‰ã‚ュメントを第一ã®æƒ…å ±æºã¨ã—ã¦åˆ©ç”¨ã—ã¦ãã ã•ã„。 アプリケーションè¨è¨ˆã«ã¤ã„ã¦ã®ã•ã‚‰ãªã‚‹æƒ…å ±ã‚„æ®µéšŽçš„ãªãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã‚’探ã—ã¦ã„ã‚‹ãªã‚‰ã€ <emphasis>Java Persistence with Hibernate</emphasis>（http://www.manning.com/bauer2） ã‚’ãŠã™ã™ã‚ã—ã¾ã™ã€‚ ã¾ãŸhttp://caveatemptor.hibernate.orgã‹ã‚‰ Java Persistence with Hibernateã®ä¾‹é¡Œã®ã‚¢ãƒ—リケーションをダウンãƒãƒ¼ãƒ‰ã§ãã¾ã™ã€‚"
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr "FAQã¯Hibernateウェブサイトã«ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr "サードパーティã®ãƒ‡ãƒ¢ã€ä¾‹ã€ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã¯Hibernateウェブサイトã«ãƒªãƒ³ã‚¯ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "Hibernateウェブサイトã®ã‚³ãƒŸãƒ¥ãƒ‹ãƒ†ã‚£ã‚¨ãƒªã‚¢ã¯ã€ãƒ‡ã‚¶ã‚¤ãƒ³ãƒ‘ターンやã•ã¾ã–ã¾ãªçµ±åˆã‚½ãƒªãƒ¥ãƒ¼ã‚·ãƒ§ãƒ³ （Tomcat, JBoss AS, Struts, EJB, ç‰ï¼‰ã«ã¤ã„ã¦ã®ã‚ˆã„æƒ…å ±æºã§ã™ã€‚"
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "質å•ãŒã‚ã‚Œã°Hibernateウェブサイトã®ãƒ¦ãƒ¼ã‚¶ãƒ•ã‚©ãƒ¼ãƒ©ãƒ を活用ã—ã¦ãã ã•ã„。 ã¾ãŸãƒã‚°ãƒ¬ãƒãƒ¼ãƒˆã¨ãƒ•ã‚£ãƒ¼ãƒãƒ£ãƒªã‚¯ã‚¨ã‚¹ãƒˆã®ãŸã‚JIRA課題追跡システムを用æ„ã—ã¦ã„ã¾ã™ã€‚ Hibernateã®é–‹ç™ºã«èˆˆå‘³ãŒã‚ã‚Œã°ã€é–‹ç™ºè€…メーリングリストã«å‚åŠ ã—ã¦ãã ã•ã„。 ã“ã®ãƒ‰ã‚ュメントをã‚ãªãŸã®å›½ã®è¨€è‘‰ã«ç¿»è¨³ã—ãŸã„å ´åˆã¯ã€ 開発者メーリングリストã§ç§ãŸã¡ã«ã‚³ãƒ³ã‚¿ã‚¯ãƒˆã‚’å–ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "商用開発ã®ã‚µãƒãƒ¼ãƒˆã€è£½å“ã®ã‚µãƒãƒ¼ãƒˆã€Hibernateã®ãƒˆãƒ¬ãƒ¼ãƒ‹ãƒ³ã‚°ã¯JBoss Inc.ãŒæä¾›ã—ã¦ã„ã¾ã™ （http://www.hibernate.org/SupportTraining/を見ã¦ãã ã•ã„）。 Hibernateã¯Professional Open Sourceプãƒã‚¸ã‚§ã‚¯ãƒˆã€ ãã—ã¦JBoss Enterprise Middleware System（JEMS）プãƒãƒ€ã‚¯ãƒˆã‚¹ã‚¤ãƒ¼ãƒˆã®ã‚¯ãƒªãƒ†ã‚£ã‚«ãƒ«ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,672 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr "Criteriaクエリ"
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr "Hibernateã«ã¯ã€ç›´æ„Ÿçš„ã§æ‹¡å¼µå¯èƒ½ãªcriteriaクエリAPIãŒç”¨æ„ã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr "<literal>Criteria</literal> インスタンスã®ä½œæˆ"
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr "<literal>org.hibernate.Criteria</literal> インターフェイスã¯ç‰¹å®šã®æ°¸ç¶šæ€§ã‚¯ãƒ©ã‚¹ã«å¯¾ã™ã‚‹ã‚¯ã‚¨ãƒªã‚’表ç¾ã—ã¾ã™ã€‚ <literal>Session</literal> 㯠<literal>Criteria</literal> インスタンスã®ãƒ•ã‚¡ã‚¯ãƒˆãƒªã§ã™ã€‚"
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr "リザルトセットã®çµžè¾¼ã¿"
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr "<literal>org.hibernate.criterion.Criterion</literal> インターフェイスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ 個別ã®ã‚¯ã‚¨ãƒªã‚¯ãƒ©ã‚¤ãƒ†ãƒªã‚ªãƒ³ï¼ˆå•ã„åˆã‚ã›ã®åˆ¤å®šåŸºæº–）を表ã—ã¾ã™ã€‚ <literal>org.hibernate.criterion.Restrictions</literal> クラスã¯ã€ã‚る組ã¿è¾¼ã¿ã® <literal>Criterion</literal> åž‹ã‚’å–å¾—ã™ã‚‹ãŸã‚ã®ãƒ•ã‚¡ã‚¯ãƒˆãƒªãƒ¡ã‚½ãƒƒãƒ‰ã‚’æŒã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr "Restriction（é™å®šï¼‰ã¯ã€è«–ç†çš„ã«ã‚°ãƒ«ãƒ¼ãƒ—化ã§ãã¾ã™ã€‚"
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr "元々ã‚ã‚‹Criterion型（<literal>Restrictions</literal> ã®ã‚µãƒ–クラス） ã¯ã‹ãªã‚Šã®ç¯„囲ã«åŠã³ã¾ã™ãŒã€ç‰¹ã«æœ‰ç”¨ãªã®ã¯SQLを直接指定ã§ãã‚‹ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr "<literal>{alias}</literal> ã¨ã„ã†ãƒ—レースホルダã¯ã€ å•ã„åˆã‚ã›ã‚’å—ã‘ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®è¡Œã®åˆ¥åã«ã‚ˆã£ã¦ç½®ãæ›ãˆã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr "criterionを得る別ã®æ‰‹æ®µã¯ã€ <literal>Property</literal> インスタンスã‹ã‚‰å–å¾—ã™ã‚‹ã“ã¨ã§ã™ã€‚ <literal>Property.forName()</literal> を呼ã³å‡ºã—ã¦ã€ <literal>Property</literal> インスタンスを作æˆã§ãã¾ã™ã€‚"
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr "çµæžœã®æ•´åˆ—"
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr "<literal>org.hibernate.criterion.Order</literal> を使ã£ã¦çµæžœã‚’並ã³æ›¿ãˆã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:81
+msgid "Associations"
+msgstr "<title>関連</title>"
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr "<literal>createCriteria()</literal> を使ã„ã€é–¢é€£ã‚’ナビゲートã™ã‚‹ã“ã¨ã§ã€ 容易ã«é–¢ä¿‚ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«åˆ¶ç´„を指定ã§ãã¾ã™ã€‚"
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr "2番目㮠<literal>createCriteria()</literal> ã¯ã€<literal>kittens</literal> コレクションã®è¦ç´ ã‚’å‚ç…§ã™ã‚‹æ–°ã—ã„ <literal>Criteria</literal> インスタンスを返ã™ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr "以下ã®ã‚ˆã†ãªæ–¹æ³•ã‚‚ã€çŠ¶æ³ã«ã‚ˆã‚Šæœ‰ç”¨ã§ã™ã€‚"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr "（<literal>createAlias()</literal> ã¯æ–°ã—ã„ <literal>Criteria</literal> インスタンスを作æˆã—ã¾ã›ã‚“。）"
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr "å‰ã®2ã¤ã®ã‚¯ã‚¨ãƒªã«ã‚ˆã£ã¦è¿”ã•ã‚Œã‚‹ <literal>Cat</literal> インスタンスã«ã‚ˆã£ã¦ä¿æŒã•ã‚Œã‚‹kittensコレクションã¯ã€ criteriaã«ã‚ˆã£ã¦äº‹å‰ã«ãƒ•ã‚£ãƒ«ã‚¿ãƒªãƒ³ã‚° <emphasis>ã•ã‚Œãªã„</emphasis> ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã‚‚ã—criteriaã«é©åˆã™ã‚‹kittenã‚’å–å¾—ã—ãŸã„ãªã‚‰ã€ <literal>ResultTransformer</literal> を使ã‚ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr "関連ã®å‹•çš„フェッãƒ"
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr "<literal>setFetchMode()</literal> を使ã„〠実行時ã«é–¢é€£ã®å¾©å…ƒæ–¹æ³•ã‚’指定ã—ã¦ã‚‚よã„ã§ã™ã€‚"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã¯å¤–部çµåˆã«ã‚ˆã‚Š <literal>mate</literal> 㨠<literal>kittens</literal> ã®ä¸¡æ–¹ã‚’フェッãƒã—ã¾ã™ã€‚ より多ãã®æƒ…å ±ã¯ <xref linkend=\"performance-fetching\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr "クエリã®ä¾‹"
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr "<literal>org.hibernate.criterion.Example</literal> クラスã¯ã€ 与ãˆã‚‰ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‹ã‚‰ã‚¯ã‚¨ãƒªã‚¯ãƒ©ã‚¤ãƒ†ãƒªã‚ªãƒ³ã‚’構築ã§ãã¾ã™ã€‚"
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティã€è˜åˆ¥åã€é–¢é€£ã¯ç„¡è¦–ã•ã‚Œã¾ã™ã€‚ デフォルトã§ã¯null値ã®ãƒ—ãƒãƒ‘ティã¯é™¤å¤–ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr "ã©ã®ã‚ˆã†ã« <literal>Example</literal> ã‚’é©ç”¨ã™ã‚‹ã‹ 調整ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr "関連オブジェクトã«criteriaを指定ã™ã‚‹ãŸã‚ã«ã€Exampleを使ã†ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr "å°„å½±ã€é›†ç´„ã€ã‚°ãƒ«ãƒ¼ãƒ—化"
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr "<literal>org.hibernate.criterion.Projections</literal> クラス㯠<literal>Projection</literal> インスタンスã®ãƒ•ã‚¡ã‚¯ãƒˆãƒªã§ã™ã€‚ <literal>setProjection()</literal> を呼ã³å‡ºã™ã“ã¨ã§ã€ クエリã«å°„影をé©ç”¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr "å¿…è¦ã§ã‚ã£ã¦ã‚‚ã€criteriaクエリã«ã€Œgroup byã€ã‚’明示ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 ã‚る種ã®Projection型㯠<emphasis>グループ化射影</emphasis> ã¨ã—ã¦å®šç¾©ã•ã‚Œã€ SQLã® <literal>group by</literal> 節ã«ã‚‚ç¾ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr "ä»»æ„ã§å°„å½±ã«åˆ¥åを付ã‘られるãŸã‚ã€å°„å½±ã•ã‚Œã‚‹å€¤ã¯restrictionã‚„ordering内ã‹ã‚‰å‚ç…§ã§ãã¾ã™ã€‚ 別åã‚’ã¤ã‘ã‚‹ï¼’ã¤ã®ç•°ãªã‚‹æ–¹æ³•ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr "<literal>alias()</literal> 㨠<literal>as()</literal> メソッドã¯ã€ Projectionインスタンスを別ã®åå‰ã® <literal>Projection</literal> インスタンス㧠ラップã™ã‚‹ã ã‘ã§ã™ã€‚ ショートカットã¨ã—ã¦ã€å°„影を射影リストã«è¿½åŠ ã™ã‚‹éš›ã«ã€åˆ¥åã‚’ã¤ã‘られã¾ã™ã€‚"
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr "å°„å½±ã®å¼ã« <literal>Property.forName()</literal> も使用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr "クエリãŠã‚ˆã³ã‚µãƒ–クエリã®åˆ†é›¢"
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr "<literal>DetachedCriteria</literal> クラスã«ã‚ˆã‚Šã€ セッションスコープ外ã«ã‚¯ã‚¨ãƒªã‚’作æˆã§ãã¾ã™ã€‚ 後ã§ã€ä»»æ„ã® <literal>Session</literal> を使ã£ã¦ã€å®Ÿè¡Œã§ãã¾ã™ã€‚"
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr "<literal>DetachedCriteria</literal> ã¯ã€ã‚µãƒ–クエリを表ç¾ã™ã‚‹ãŸã‚ã«ã‚‚使ãˆã¾ã™ã€‚ サブクエリを伴ã†Criterionインスタンスã¯ã€ <literal>Subqueries</literal> ã‚‚ã—ã㯠<literal>Property</literal> ã‹ã‚‰å¾—られã¾ã™ã€‚"
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr "相互関係ãŒã‚るサブクエリã§ã•ãˆã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr "自然è˜åˆ¥åã«ã‚ˆã‚‹ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr "criteriaクエリをå«ã‚€ãŸã„ã¦ã„ã®ã‚¯ã‚¨ãƒªã«ã¨ã£ã¦ã€ クエリã‚ャッシュã¯ã‚ã¾ã‚ŠåŠ¹çŽ‡ãŒã‚ˆããªã„ã§ã™ã€‚ ãªãœãªã‚‰ã€ã‚¯ã‚¨ãƒªã‚ャッシュãŒé »ç¹ã«ç„¡åŠ¹ã«ãªã‚‹ãŸã‚ã§ã™ã€‚ ã—ã‹ã—ãªãŒã‚‰ã€ã‚ャッシュを無効ã«ã™ã‚‹ã‚¢ãƒ«ã‚´ãƒªã‚ºãƒ を最é©åŒ–ã§ãã‚‹ 特別ãªã‚¯ã‚¨ãƒªã®ç¨®é¡žãŒï¼‘ã¤ã‚ã‚Šã¾ã™ã€‚ æ›´æ–°ã•ã‚Œãªã„自然ã‚ーã«ã‚ˆã‚‹æ¤œç´¢ã§ã™ã€‚ ã„ãã¤ã‹ã®ã‚¢ãƒ—リケーションã§ã¯ã€ã“ã®ç¨®é¡žã®ã‚¯ã‚¨ãƒªãŒé »ç¹ã«ç¾ã‚Œã¾ã™ã€‚ ã“ã®ã‚ˆã†ãªä½¿ã‚れ方ã®ãŸã‚ã«ã€criteria APIã¯ç‰¹åˆ¥ãªå¯¾ç–ã‚’æä¾›ã—ã¾ã™ã€‚"
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr "最åˆã«ã€<literal><natural-id></literal> を使ã£ã¦ã€ エンティティã®è‡ªç„¶ã‚ーをマップã—ã¦ãã ã•ã„。 ãã—ã¦ã€äºŒæ¬¡ã‚ャッシュを有効ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr "注æ„： <emphasis>変更ã•ã‚Œã‚‹</emphasis> 自然ã‚ーをæŒã¤ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã« ã“ã®æ©Ÿèƒ½ã‚’使ã†ã®ã¯ã€æ„図ã•ã‚Œã¦ã„ãªã„使ã„æ–¹ã§ã™ã€‚"
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr "次ã«ã€Hibernateクエリã‚ャッシュを有効ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr "ã“ã‚Œã§ã€<literal>Restrictions.naturalId()</literal> ã«ã‚ˆã‚Šã€ より効率的ãªã‚ャッシュアルゴリズムを使用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1694 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr "HQL: The Hibernate Query Language"
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr "Hibernateã¯SQLã«éžå¸¸ã«ã‚ˆãä¼¼ãŸ(æ„図的ã«ä¼¼ã›ãŸ)強力ãªå•ã„åˆã‚ã›è¨€èªžã‚’å‚™ãˆã¦ã„ã¾ã™ã€‚ ã—ã‹ã—SQLã«ä¼¼ãŸæ§‹æ–‡ã«æƒ‘ã‚ã•ã‚Œãªã„ã§ãã ã•ã„。HQLã¯å®Œå…¨ã«ã‚ªãƒ–ジェクト指å‘ã§ã‚り〠継承ã€ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ã‚ºãƒ ã€é–¢é€£ã¨ã„ã£ãŸæ¦‚念をç†è§£ã—ã¾ã™ã€‚"
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr "大文å—ã¨å°æ–‡å—ã®åŒºåˆ¥"
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr "クエリã¯Javaã®ã‚¯ãƒ©ã‚¹åã¨ãƒ—ãƒãƒ‘ティåを除ã„ã¦å¤§æ–‡å—ã€å°æ–‡å—を区別ã—ã¾ã›ã‚“。 従ã£ã¦ <literal>SeLeCT</literal> 㯠<literal>sELEct</literal> ã¨åŒã˜ã§ã€ã‹ã¤ <literal>SELECT</literal> ã¨ã‚‚åŒã˜ã§ã™ãŒ <literal>net.sf.hibernate.eg.FOO</literal> 㯠<literal>net.sf.hibernate.eg.Foo</literal> ã¨ã¯é•ã„ã€ã‹ã¤ <literal>foo.barSet</literal> 㯠<literal>foo.BARSET</literal> ã¨ã‚‚é•ã„ã¾ã™ã€‚"
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr "ã“ã®ãƒžãƒ‹ãƒ¥ã‚¢ãƒ«ã§ã¯å°æ–‡å—ã®HQLã‚ーワードを使用ã—ã¾ã™ã€‚ 大文å—ã®ã‚ーワードã®ã‚¯ã‚¨ãƒªã®æ–¹ãŒèªã¿ã‚„ã™ã„ã¨æ„Ÿã˜ã‚‹ãƒ¦ãƒ¼ã‚¶ãƒ¼ã‚‚ã„ã‚‹ã¨æ€ã„ã¾ã™ã€‚ ã§ã™ãŒã€Javaコード内ã«åŸ‹ã‚è¾¼ã¾ã‚ŒãŸã¨ãã«ã¯è¦‹ã¥ã‚‰ã„ã¨æ€ã„ã¾ã™ã€‚"
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr "from節"
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr "ã‚‚ã£ã¨ã‚‚å˜ç´”ãªHibernateクエリã¯æ¬¡ã®å½¢å¼ã§ã™ã€‚"
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr "<![CDATA[from eg.Cat]]>"
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr "ã“ã‚Œã¯å˜ç´”ã«ã€€<literal>eg.Cat</literal>　クラスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’ã™ã¹ã¦è¿”ã—ã¾ã™ã€‚ å¿…ãšã—もクラスåを修飾ã™ã‚‹ï¼ˆã‚¯ãƒ©ã‚¹ã«ãƒ‘ッケージåを付ã‘る）必è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 ã¨ã„ã†ã®ã‚‚ã€<literal>auto-import</literal> ãŒãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã«ãªã£ã¦ã„ã‚‹ã‹ã‚‰ã§ã™ã€‚ ãã®ãŸã‚ã»ã¨ã‚“ã©ã®å ´åˆã€ã“ã®ã‚ˆã†ã«æ›¸ãã ã‘ã§å分ã§ã™ã€‚"
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr "<![CDATA[from Cat]]>"
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr "ã»ã¨ã‚“ã©ã®å ´åˆã‚¯ã‚¨ãƒªã®ã»ã‹ã®éƒ¨åˆ†ã§ã€€<literal>Cat</literal>　をå‚ç…§ã™ã‚‹ã®ã§ã€åˆ¥åを割り当ã¦ã‚‹å¿…è¦ãŒã‚ã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã§ã¯ <literal>Cat</literal> インスタンス㫠<literal>cat</literal> ã¨ã„ã†åˆ¥åを付ã‘ã¦ã„ã¾ã™ã€‚ ãã®ãŸã‚ã€å¾Œã§ã“ã®ã‚¯ã‚¨ãƒªå†…ã§ã€ã“ã®åˆ¥åを使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal>as</literal> ã‚ーワードã¯ã‚ªãƒ—ションã§ã™ã€‚ã¤ã¾ã‚Šã“ã®ã‚ˆã†ã«æ›¸ãã“ã¨ã‚‚ã§ãã¾ã™ï¼š"
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr "<![CDATA[from Cat cat]]>"
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr "ç›´ç©ã€ã‚ã‚‹ã„ã¯ã‚¯ãƒã‚¹çµåˆã«ã‚ˆã£ã¦å¤šæ•°ã®ã‚¯ãƒ©ã‚¹ãŒå‡ºç¾ã™ã‚‹ã“ã¨ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr "<![CDATA[from Formula, Parameter]]>"
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr "<![CDATA[from Formula as form, Parameter as param]]>"
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr "ãƒãƒ¼ã‚«ãƒ«å¤‰æ•°ã®Javaã®ãƒãƒ¼ãƒŸãƒ³ã‚°åŸºæº–ã¨ä¸€è‡´ã—ãŸã€ é æ–‡å—ã«å°æ–‡å—を使ã£ãŸã‚¯ã‚¨ãƒªã®åˆ¥åを付ã‘ã‚‹ã“ã¨ã¯ã„ã„ç¿’æ…£ã§ã™(例ãˆã° <literal>domesticCat</literal> )。"
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr "関連ã¨çµåˆ"
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr "関連ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚ã‚‹ã„ã¯å€¤ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ã«ã‚‚ã€<literal>çµåˆ</literal> を使ã£ã¦åˆ¥åを割り当ã¦ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ " inner join cat.mate as mate
+\n"
+ " left outer join cat.kittens as kitten]]>"
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr "<![CDATA[from Formula form full join form.parameter param]]>"
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr "サãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹çµåˆã®ã‚¿ã‚¤ãƒ—ã¯ANSI SQLã¨åŒã˜ã§ã™ã€‚"
+
+#: index.docbook:103
+msgid "inner join"
+msgstr "inner join"
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr "left outer join"
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr "right outer join"
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr "<literal>full join</literal> (ãŸã„ã¦ã„ã®å ´åˆä½¿ã„ã¥ã‚‰ã„)"
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr "<literal>inner join</literal>ã€<literal>left outer join</literal>ã€<literal>right outer join</literal>ã«ã¯çœç•¥å½¢ã‚’使ã†ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ " join cat.mate as mate
+\n"
+ " left join cat.kittens as kitten]]>"
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr "HQLã® <literal>with</literal> ã‚ーワードを使ã†ã¨ã€çµåˆæ¡ä»¶ã‚’付ã‘åŠ ãˆã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ " left join cat.kittens as kitten
+\n"
+ " with kitten.bodyWeight > 10.0]]>"
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "åŠ ãˆã¦ã€ã€Œãƒ•ã‚§ãƒƒãƒã€çµåˆã¯é–¢é€£ã‚„値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’親オブジェクトã¨ä¸€ç·’ã«1度ã®selectå¥ã§åˆæœŸåŒ–ã—ã¾ã™ã€‚ ã“ã‚Œã¯ç‰¹ã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å ´åˆã«æœ‰ç”¨ã§ã™ã€‚ã“ã‚Œã¯å®Ÿè³ªä¸Šã€é–¢é€£ã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã™ã‚‹ãƒžãƒƒãƒ”ング定義ファイルã®å¤–部çµåˆã¨lazyåˆæœŸåŒ–ã®å®šç¾©ã‚’上書ãã™ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ <xref linkend=\"performance-fetching\"/> ã«ã‚ˆã‚Šå¤šãã®æƒ…å ±ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ " inner join fetch cat.mate
+\n"
+ " left join fetch cat.kittens]]>"
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr "çµåˆã«ã‚ˆã‚‹ãƒ•ã‚§ãƒƒãƒã¯é–¢é€£ã™ã‚‹ã‚ªãƒ–ジェクト㌠<literal>where</literal> 節(ã¾ãŸã¯ä»–ã®ã©ã‚“ãªç¯€ã§ã‚‚) ã§ä½¿ã‚ã‚Œã¦ã¯ãªã‚‰ãªã„ã®ã§ã€é€šå¸¸åˆ¥åを割り当ã¦ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã›ã‚“。ã¾ãŸé–¢é€£ã‚ªãƒ–ジェクトã¯å•ã„åˆã‚ã›çµæžœã¨ã—㦠直接返ã•ã‚Œã¾ã›ã‚“。代ã‚ã‚Šã«è¦ªã‚ªãƒ–ジェクトを通ã—ã¦ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã™ã€‚ コレクションをå†å¸°çš„ã«çµåˆãƒ•ã‚§ãƒƒãƒã™ã‚‹å ´åˆã®ã¿ã€åˆ¥åãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ " inner join fetch cat.mate
+\n"
+ " left join fetch cat.kittens child
+\n"
+ " left join fetch child.kittens]]>"
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr "<literal>fetch</literal> 構文㯠<literal>iterate()</literal> を使ã£ãŸã‚¯ã‚¨ãƒªå‘¼ã³å‡ºã—ã§ä½¿ç”¨ã§ããªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„ （一方㧠<literal>scroll()</literal> ã¯ä½¿ç”¨ã§ãã¾ã™ï¼‰ã€‚ ã¾ãŸã€ã“れらã®æ“作ã¯çµæžœã®è¡Œã«åŸºã¥ã„ã¦ã„ã‚‹ãŸã‚〠<literal>fetch</literal> 㯠<literal>setMaxResults()</literal> ã‚„ <literal>setFirstResult()</literal> ã¨ä¸€ç·’ã«ä½¿ç”¨ã™ã¹ãã§ã¯ã‚ã‚Šã¾ã›ã‚“。 通常eagerãªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒ•ã‚§ãƒƒãƒã‚’ã™ã‚‹ã¨é‡è¤‡ãŒå‡ºã¦ã—ã¾ã†ãŸã‚ã€ã‚ãªãŸãŒæœŸå¾…ã™ã‚‹ã‚ˆã†ãªè¡Œæ•°ã«ã¯ãªã‚‰ãªã„ã®ã§ã™ã€‚ ãã—ã¦ã¾ãŸ <literal>fetch</literal> ã¯ã€ã‚¢ãƒ‰ãƒ›ãƒƒã‚¯ãª <literal>with</literal> æ¡ä»¶ã‚’ 一緒ã«ä½¿ã†ã“ã¨ã‚‚ã§ãã¾ã›ã‚“。 一ã¤ã®ã‚¯ã‚¨ãƒªã§è¤‡æ•°ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’çµåˆãƒ•ã‚§ãƒƒãƒã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šç›´ç©ã‚’作æˆã§ãã‚‹ã®ã§ã€ã“ã®å ´åˆæ³¨æ„ã—ã¦ãã ã•ã„。 ã¾ãŸã€è¤‡æ•°ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«å¯¾ã™ã‚‹çµåˆãƒ•ã‚§ãƒƒãƒ!
ã¯bagマッピングã«å¯¾ã—ã¦äºˆæœŸã›ã¬çµæžœã‚’ã‚‚ãŸã‚‰ã™ã“ã¨ãŒã‚ã‚‹ã®ã§ã€ ã“ã®å ´åˆã®ã‚¯ã‚¨ãƒªã®ä½œæˆã«ã¯æ³¨æ„ã—ã¦ãã ã•ã„。 最後㫠<literal>全外部çµåˆã«ã‚ˆã‚‹ãƒ•ã‚§ãƒƒãƒ</literal> 㨠<literal>å³å¤–部çµåˆã«ã‚ˆã‚‹ãƒ•ã‚§ãƒƒãƒ</literal> ã¯æœ‰ç”¨ã§ã¯ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr "ã‚‚ã—プãƒãƒ‘ティレベルã®é…延フェッãƒã‚’使ã†å ´åˆï¼ˆå†…部的ã«ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰å‡¦ç†ã‚’ã™ã‚‹å ´åˆï¼‰ã€ <literal>fetch all properties</literal> を使ã†ã“ã¨ã§ Hibernateã«é…延プãƒãƒ‘ティを速やã‹ã«ï¼ˆæœ€åˆã®ã‚¯ã‚¨ãƒªã§ï¼‰ãƒ•ã‚§ãƒƒãƒã•ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr "<![CDATA[from Document fetch all properties order by name]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr "çµåˆæ§‹æ–‡ã®å½¢å¼"
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr "HQLã¯ï¼’ã¤ã®é–¢é€£çµåˆå½¢å¼ã‚’サãƒãƒ¼ãƒˆã—ã¾ã™ï¼š<literal>暗黙的</literal> 㨠<literal>明示的</literal>。"
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr "ã“ã‚Œã¾ã§ã®ã‚»ã‚¯ã‚·ãƒ§ãƒ³ã§ãŠè¦‹ã›ã—ãŸä½¿ã„æ–¹ã¯ã™ã¹ã¦ <literal>明示的ãª</literal> å½¢å¼ã§ã€ from節ã§æ˜Žç¤ºçš„ã«joinã‚ーワードを使ã£ã¦ã„ã¾ã™ã€‚ ã“ã®å½¢å¼ã‚’ãŠã™ã™ã‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr "<literal>暗黙的</literal> フォームã¯ã€joinã‚ーワードを使ã„ã¾ã›ã‚“。代ã‚ã‚Šã«ã€å‚ç…§ã™ã‚‹é–¢é€£ã« ドット表記を使ã„ã¾ã™ã€‚<literal>暗黙的</literal> çµåˆã¯ã€ã•ã¾ã–ã¾ãªHQLã«å‡ºã¦ãã¾ã™ã€‚ <literal>暗黙的</literal> çµåˆã®çµæžœã¯ã€SQLステートメントã®å†…部çµåˆçµæžœã§ã™ã€‚"
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr "Select節"
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr "<literal>select</literal> 節ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ã©ã®ã‚ªãƒ–ジェクトã¨å±žæ€§ã‚’クエリリザルトセットã«è¿”ã™ã‹ã‚’é¸æŠžã—ã¾ã™ã€‚:"
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr ""
+ "<![CDATA[select mate
+\n"
+ "from Cat as cat
+\n"
+ " inner join cat.mate as mate]]>"
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr "上記ã®ã‚¯ã‚¨ãƒªã¯ä»–ã® <literal>Cat</literal> ã® <literal>mate</literal> ã‚’é¸æŠžã—ã¾ã™ã€‚ 実際ã«ã¯æ¬¡ã®ã‚ˆã†ã«ã€ã‚ˆã‚Šç°¡æ½”ã«è¡¨ç¾ã§ãã¾ã™ã€‚:"
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr "<![CDATA[select cat.mate from Cat cat]]>"
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr "クエリã¯ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆåž‹ã®ãƒ—ãƒãƒ‘ティをå«ã‚€ã€ã‚らゆる値型ã®ãƒ—ãƒãƒ‘ティも返ã›ã¾ã™ã€‚:"
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr ""
+ "<![CDATA[select cat.name from DomesticCat cat
+\n"
+ "where cat.name like 'fri%']]>"
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr "クエリã¯è¤‡æ•°ã®ã‚ªãƒ–ジェクトã¨(ã¾ãŸã¯)プãƒãƒ‘ティを <literal>Object[]</literal> åž‹ã®é…列ã¨ã—ã¦è¿”ã›ã¾ã™ã€‚"
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr ""
+ "<![CDATA[select mother, offspr, mate.name
+\n"
+ "from DomesticCat as mother
+\n"
+ " inner join mother.mate as mate
+\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr "ã‚‚ã—ã㯠<literal>List</literal> ã¨ã—ã¦ã€"
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+ "<![CDATA[select new list(mother, offspr, mate.name)
+\n"
+ "from DomesticCat as mother
+\n"
+ " inner join mother.mate as mate
+\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr "ã¾ãŸã¯ã€ã‚¿ã‚¤ãƒ—セーフãªJavaオブジェクトを返ã›ã¾ã™ã€‚"
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr ""
+ "<![CDATA[select new Family(mother, mate, offspr)
+\n"
+ "from DomesticCat as mother
+\n"
+ " join mother.mate as mate
+\n"
+ " left join mother.kittens as offspr]]>"
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr "ã‚ã‚‹ã„㯠<literal>Family</literal> クラスãŒé©åˆ‡ãªã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ã‚’æŒã£ã¦ã„ã‚‹ã¨ã™ã‚‹ãªã‚‰ã°ã€"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr "select節㫠<literal>as</literal> を使ã£ã¦åˆ¥åã‚’ã¤ã‘ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
+\n"
+ "from Cat cat]]>"
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr "<literal>select new map</literal> ã¨ä¸€ç·’ã«ä½¿ã†ã¨ãã«æœ€ã‚‚役立ã¡ã¾ã™ï¼š"
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
+\n"
+ "from Cat cat]]>"
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã¯åˆ¥åã‹ã‚‰selectã—ãŸå€¤ã¸ <literal>Map</literal> ã‚’è¿”ã—ã¾ã™ã€‚"
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr "集約関数"
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr "HQLã®ã‚¯ã‚¨ãƒªã¯ãƒ—ãƒãƒ‘ティã®é›†ç´„関数ã®çµæžœã‚‚è¿”ã›ã¾ã™ï¼š"
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
+\n"
+ "from Cat cat]]>"
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr "サãƒãƒ¼ãƒˆã—ã¦ã„る集約関数ã¯ä»¥ä¸‹ã®ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr "avg(...), sum(...), min(...), max(...)"
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr "count(*)"
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr "count(...), count(distinct ...), count(all...)"
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr "select節ã«ãŠã„ã¦ç®—è¡“æ“作ã€é€£çµã¨æ‰¿èªã•ã‚ŒãŸSQL関数を使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)
+\n"
+ "from Cat cat
+\n"
+ " join cat.kittens kitten
+\n"
+ "group by cat.id, cat.weight]]>"
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr "SQLã¨åŒã˜æ„味をæŒã¤ <literal>distinct</literal> 㨠<literal>all</literal> ã‚ーワードを使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr ""
+ "<![CDATA[select distinct cat.name from Cat cat
+\n"
+ "
+\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr "ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªã‚¯ã‚¨ãƒª"
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr "次ã®ã‚ˆã†ãªã‚¯ã‚¨ãƒªï¼š"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr "<literal>Cat</literal> インスタンスã ã‘ã§ã¯ãªãã€<literal>DomesticCat</literal> ã®ã‚ˆã†ãªã‚µãƒ–クラスも返ã•ã‚Œã¾ã™ã€‚Hibernateクエリ㯠<emphasis>ã©ã‚“ãª</emphasis> Javaクラスやインターフェイスも <literal>from</literal> 節ã«å…¥ã‚Œã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ クエリã¯ãã®ã‚¯ãƒ©ã‚¹ã‚’æ‹¡å¼µã—ãŸã€ã‚‚ã—ãã¯ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ã‚¤ã‚¹ã‚’実装ã—ãŸå…¨ã¦ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã‚’è¿”ã—ã¾ã™ã€‚ 次ã®ã‚¯ã‚¨ãƒªã¯æ°¸ç¶šã‚ªãƒ–ジェクトをã™ã¹ã¦è¿”ã—ã¾ã™:"
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr "<![CDATA[from java.lang.Object o]]>"
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr "<literal>Named</literal> インターフェイスã¯æ§˜ã€…ãªæ°¸ç¶šã‚¯ãƒ©ã‚¹ã«ã‚ˆã£ã¦å®Ÿè£…ã•ã‚Œã¾ã™ã€‚:"
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr "最後ã®äºŒã¤ã®ã‚¯ã‚¨ãƒªã¯ã€äºŒã¤ä»¥ä¸Šã®SQL <literal>SELECT</literal> ã‚’è¦æ±‚ã—ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã®ã“ã¨ã¯ <literal>order by</literal> 節ãŒãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆå…¨ä½“ã‚’æ£ç¢ºã«ã¯æ•´åˆ—ã—ãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ (ã•ã‚‰ã«ãã‚Œã¯ã€<literal>Query.scroll()</literal> を使用ã—ã¦ã“れらã®ã‚¯ã‚¨ãƒªã‚’呼ã¶ã“ã¨ãŒã§ããªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚)。"
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr "<literal>where</literal> 節ã¯è¿”ã•ã‚Œã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒªã‚¹ãƒˆã‚’絞るã“ã¨ãŒã§ãã¾ã™ã€‚ ã‚‚ã—別åãŒãªã„å ´åˆã€åå‰ã§ãƒ—ãƒãƒ‘ティをå‚ç…§ã—ã¾ã™ã€‚"
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr "<![CDATA[from Cat where name='Fritz']]>"
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr "ã‚‚ã—別åãŒã‚ã‚‹å ´åˆã€ä¿®é£¾åを使ã£ã¦ãã ã•ã„。"
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr "åå‰ãŒ'Fritz'ã¨ã„ㆠ<literal>Cat</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’è¿”ã—ã¾ã™ã€‚"
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr ""
+ "<![CDATA[select foo
+\n"
+ "from Foo foo, Bar bar
+\n"
+ "where foo.startDate = bar.date]]>"
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr "上ã®HQLã¯ã€<literal>Foo</literal> ã® <literal>startDate</literal> プãƒãƒ‘ティã¨ç‰ã—ã„ <literal>date</literal> プãƒãƒ‘ティをæŒã£ãŸ <literal>bar</literal> インスタンスãŒå˜åœ¨ã™ã‚‹ã€ ã™ã¹ã¦ã® <literal>Foo</literal> インスタンスを返ã—ã¾ã™ã€‚ コンパウンドパスå¼ï¼ˆä¾‹ãˆã°ã€Œcat.mate.nameã€ï¼‰ã¯ <literal>where</literal> 節をéžå¸¸ã«å¼·åŠ›ã«ã—ã¾ã™ã€‚注目："
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã¯ãƒ†ãƒ¼ãƒ–ルçµåˆï¼ˆå†…部çµåˆï¼‰ã‚’æŒã¤SQLクエリã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚ ãã®ä»£ã‚ã‚Šã«ä»¥ä¸‹ã®ã‚ˆã†ã«æ›¸ãã¨ã€"
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr ""
+ "<![CDATA[from Foo foo
+\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr "ã‚‚ã—上ã®ã‚¯ã‚¨ãƒªã‚’記述ã—ãŸã‚‰ã‚¯ã‚¨ãƒªå†…ã«4ã¤ã®ãƒ†ãƒ¼ãƒ–ルçµåˆã‚’å¿…è¦ã¨ã™ã‚‹SQLクエリã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr "<literal>=</literal> 演算åã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ã€ãƒ—ãƒãƒ‘ティã ã‘ã§ãªãインスタンスを比較ã™ã‚‹ãŸã‚ã«ã‚‚使ã‚ã‚Œã¾ã™ã€‚："
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr ""
+ "<![CDATA[select cat, mate
+\n"
+ "from Cat cat, Cat mate
+\n"
+ "where cat.mate = mate]]>"
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr "<literal>id</literal> (å°æ–‡å—)ã¯ç‰¹åˆ¥ãªãƒ—ãƒãƒ‘ティã§ã‚り〠オブジェクトã®ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åã‚’å‚ç…§ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã§ãã¾ã™ã€‚(ã•ã‚‰ã«ã€ãã®ãƒ—ãƒãƒ‘ティåを使用ã§ãã¾ã™ã€‚)"
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat where cat.id = 123
+\n"
+ "
+\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr "2番目ã®ã‚¯ã‚¨ãƒªã¯åŠ¹çŽ‡çš„ã§ã™ã€‚テーブルçµåˆãŒå¿…è¦ã‚ã‚Šã¾ã›ã‚“ï¼"
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr "ã¾ãŸè¤‡åˆè˜åˆ¥åã®ãƒ—ãƒãƒ‘ティも使用ã§ãã¾ã™ã€‚ã“ã“㧠<literal>Person</literal> ㌠<literal>country</literal> 㨠<literal>medicareNumber</literal> ã‹ã‚‰ãªã‚‹è¤‡åˆè˜åˆ¥åã‚’æŒã¤ã¨ä»®å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr ""
+ "<![CDATA[from bank.Person person
+\n"
+ "where person.id.country = 'AU'
+\n"
+ " and person.id.medicareNumber = 123456]]>"
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+ "<![CDATA[from bank.Account account
+\n"
+ "where account.owner.id.country = 'AU'
+\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr "ã‚‚ã†ä¸€åº¦è¨€ã„ã¾ã™ãŒã€2番目ã®ã‚¯ã‚¨ãƒªã«ã¯ãƒ†ãƒ¼ãƒ–ルçµåˆãŒå¿…è¦ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr "åŒæ§˜ã« <literal>class</literal> ã¯ç‰¹åˆ¥ãªãƒ—ãƒãƒ‘ティã§ã‚り〠ãƒãƒªãƒ¢ãƒ¼ãƒ•ã‚£ãƒƒã‚¯ãªæ°¸ç¶šåŒ–ã«ãŠã‘るインスタンスã®discriminator値ã«ã‚¢ã‚¯ã‚»ã‚¹ã—ã¾ã™ã€‚ where節ã«åŸ‹ã‚è¾¼ã¾ã‚ŒãŸJavaã®ã‚¯ãƒ©ã‚¹åã¯ãã®discriminator値ã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr "ã¾ãŸã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚„複åˆãƒ¦ãƒ¼ã‚¶åž‹(ã¾ãŸãã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã®ã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆãªã©)ã®ãƒ—ãƒãƒ‘ティも指定ã§ãã¾ã™ã€‚ ã—ã‹ã—決ã—ã¦ï¼ˆã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã®ãƒ—ãƒãƒ‘ティã§ã¯ãªã）コンãƒãƒ¼ãƒãƒ³ãƒˆåž‹ã®ãƒ—ãƒãƒ‘ティã§çµ‚了ã™ã‚‹ãƒ‘スå¼ã‚’使ã‚ãªã„ã§ãã ã•ã„。 例ãˆã°ã‚‚ã— <literal>store.owner</literal> ㌠<literal>address</literal> コンãƒãƒ¼ãƒãƒ³ãƒˆã‚’æŒã¤ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãªã‚‰ã°ä»¥ä¸‹ã®ã‚ˆã†ãªçµæžœã¨ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr ""
+ "<![CDATA[store.owner.address.city // okay
+\n"
+ "store.owner.address // error!]]>"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr "\"any\"åž‹ã¯ç‰¹åˆ¥ãªãƒ—ãƒãƒ‘ティã§ã‚ã‚‹ <literal>id</literal> 㨠<literal>class</literal> ã‚’æŒã¡ã€ 以下ã®æ–¹æ³•ã§çµåˆã‚’表ç¾ã™ã‚‹ã“ã¨ã‚’å¯èƒ½ã«ã—ã¾ã™(<literal>AuditLog.item</literal> 㯠<literal><any></literal> ã§ãƒžãƒƒãƒ”ングã•ã‚ŒãŸãƒ—ãƒãƒ‘ティã§ã™)。"
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr ""
+ "<![CDATA[from AuditLog log, Payment payment
+\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr "<literal>log.item.class</literal> 㨠<literal>payment.class</literal> ㌠上記ã®ã‚¯ã‚¨ãƒªä¸ã§å…¨ãç•°ãªã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚«ãƒ©ãƒ ã®å€¤ã‚’å‚ç…§ã™ã‚‹ã¨ã„ã†ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr "Expressions å¼"
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr "SQLã® <literal>where</literal> 節ã§è¨˜è¿°ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã‚‹å¼ã®ã»ã¨ã‚“ã©ã‚’HQLã§ã‚‚記述ã§ãã¾ã™ã€‚:"
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr "算術演算å：<literal>+, -, *, /</literal>"
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr "2é …æ¯”è¼ƒæ¼”ç®—å：<literal>=, >=, <=, <>, !=, like</literal>"
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr "è«–ç†æ¼”ç®—å：<literal>and, or, not</literal>"
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr "グループ分ã‘を表ã™æ‹¬å¼§ï¼š<literal>( )</literal>"
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr "\"シンプル\"ãªcase <literal>case ... when ... then ... else ... end</literal>〠\"探索的\"ãªcase <literal>case when ... then ... else ... end</literal>"
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr "ストリングã®é€£çµ <literal>...||...</literal> ã¾ãŸã¯ <literal>concat(...,...)</literal>"
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr "EJB-QL 3.0ã§å®šç¾©ã•ã‚Œã¦ã„る関数や演算å: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length()</literal>"
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr "<literal>coalesce()</literal> 㨠<literal>nullif()</literal>"
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr "æ•°å—や時間ã®å€¤ã‚’Stringã«ã‚³ãƒ³ãƒãƒ¼ãƒˆã™ã‚‹ <literal>str()</literal>）"
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr "2番目ã®å¼•æ•°ãŒHibernateåž‹ã®åå‰ã§ã‚ã‚‹ <literal>cast(... as ...)</literal> 㨠<literal>extract(... from ...)</literal>。 ãŸã ã—使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒANSI <literal>cast()</literal> 㨠<literal>extract()</literal> をサãƒãƒ¼ãƒˆã™ã‚‹å ´åˆã«é™ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr "çµåˆã—ãŸã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ä»˜ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®åˆ¥åã«é©ç”¨ã•ã‚Œã‚‹HQLã® <literal>index()</literal> 関数。"
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr "コレクション値ã®ãƒ‘スå¼ã‚’å–ã‚‹HQL関数： <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal> 。 <literal>some, all, exists, any, in</literal> を使ã£ã¦ä¿®é£¾ã™ã‚‹ã“ã¨ãŒã§ãる特別㪠<literal>elements()</literal> 㨠<literal>indices</literal> 関数ã¨ä¸€ç·’ã«ä½¿ã„ã¾ã™ã€‚"
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr "<literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal> ã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒã‚µãƒãƒ¼ãƒˆã™ã‚‹SQLスカラ関数。"
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr "JDBCスタイルã®ä½ç½®ãƒ‘ラメータ <literal>?</literal>"
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr "åå‰ä»˜ãパラメータ: <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr "SQLリテラル：<literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr "Java㮠<literal>public static final</literal> 定数：<literal>eg.Color.TABBY</literal>"
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr "<literal>in</literal> 㨠<literal>between</literal> ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ä½¿ç”¨ã§ãã¾ã™ã€‚:"
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr "ã¾ãŸã€å¦å®šå½¢ã§è¨˜è¿°ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr "åŒæ§˜ã« <literal>is null</literal> ã‚„ <literal>is not null</literal> ã¯null値をテストã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã§ãã¾ã™ã€‚"
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "Hibernateè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã§HQL query substitutionsを定義ã™ã‚Œã°ã€boolean値をå¼ã®ä¸ã§ç°¡å˜ã«ä½¿ç”¨ã§ãã¾ã€‚："
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr "ã“ã†ã™ã‚‹ã“ã¨ã§ä¸‹è¨˜ã®HQLã‚’SQLã«å¤‰æ›ã™ã‚‹ã¨ãã« <literal>true</literal> , <literal>false</literal> ã‚ーワード㯠<literal>1</literal> , <literal>0</literal> ã«ç½®ãæ›ãˆã‚‰ã‚Œã¾ã™ã€‚:"
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from Cat cat where cat.alive = true]]>"
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr "特別ãªãƒ—ãƒãƒ‘ティ <literal>size</literal>ã€ã¾ãŸã¯ç‰¹åˆ¥ãªé–¢æ•° <literal>size()</literal> を使ã£ã¦ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚µã‚¤ã‚ºã‚’テストã§ãã¾ã™ã€‚:"
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr "インデックス付ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã§ã¯ã€<literal>minindex</literal> 㨠<literal>maxindex</literal> 関数を使ã£ã¦ã€ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã®æœ€å°å€¤ã¨æœ€å¤§å€¤ã‚’å‚ç…§ã§ãã¾ã™ã€‚ åŒæ§˜ã«ã€<literal>minelement</literal> 㨠<literal>maxelement</literal> を使ã£ã¦ã€ 基本型ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³è¦ç´ ã®æœ€å°å€¤ã¨æœ€å¤§å€¤ã‚’å‚ç…§ã§ãã¾ã™ã€‚"
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr "コレクションã®è¦ç´ やインデックスã®ã‚»ãƒƒãƒˆï¼ˆ<literal>elements</literal> 㨠<literal>indices</literal> 関数）ã€ã¾ãŸã¯å‰¯å•ã„åˆã‚ã›ï¼ˆå¾Œè¿°ï¼‰ã®çµæžœãŒå—ã‘å–れるã¨ãã¯ã€ SQL関数 <literal>any, some, all, exists, in</literal> ãŒã‚µãƒãƒ¼ãƒˆã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit
+\n"
+ "where kit in elements(foo.kittens)]]>"
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr ""
+ "<![CDATA[select p from NameList list, Person p
+\n"
+ "where p.name = some elements(list.names)]]>"
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr "<literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> ã¯Hibernate3ã®where節ã ã‘ã§åˆ©ç”¨å¯èƒ½ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr "インデックス付ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆarrays, lists, maps）ã®è¦ç´ ã¯ã€ インデックスã§å‚ç…§ã§ãã¾ã™ï¼ˆwhere節内ã§ã®ã¿ï¼‰ã€‚"
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr ""
+ "<![CDATA[select person from Person person, Calendar calendar
+\n"
+ "where calendar.holidays['national day'] = person.birthDay
+\n"
+ " and person.nationality.calendar = calendar]]>"
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order
+\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr ""
+ "<![CDATA[select item from Item item, Order order
+\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr "<literal>[]</literal> 内部ã®å¼ã¯ã€ç®—è¡“å¼ã§ã‚‚構ã„ã¾ã›ã‚“。"
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order
+\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr "一対多関連や値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ã«å¯¾ã—ã¦ã¯ã€HQLã¯çµ„ã¿è¾¼ã¿ã® <literal>index()</literal> 関数も用æ„ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr ""
+ "<![CDATA[select item, index(item) from Order order
+\n"
+ " join order.items item
+\n"
+ "where index(item) < 5]]>"
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr "ベースã¨ãªã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒã‚µãƒãƒ¼ãƒˆã—ã¦ã„るスカラーSQL関数ãŒä½¿ç”¨ã§ãã¾ã™"
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr "ã‚‚ã—ã¾ã å…¨ã¦ã‚’ç†è§£ã—ã¦ã„ãªã„ãªã‚‰ã€ä¸‹ã®ã‚¯ã‚¨ãƒªã‚’SQLã§ã©ã‚Œã ã‘é•·ãã€èªã¿ã¥ã‚‰ã出æ¥ã‚‹ã‹è€ƒãˆã¦ãã ã•ã„。:"
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+ "<![CDATA[select cust
+\n"
+ "from Product prod,
+\n"
+ " Store store
+\n"
+ " inner join store.customers cust
+\n"
+ "where prod.name = 'widget'
+\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )
+\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr "<emphasis>ヒント:</emphasis> 例ãˆã°ã“ã®ã‚ˆã†ã«å‡ºæ¥ã¾ã™ã€‚"
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
+\n"
+ "FROM customers cust,
+\n"
+ " stores store,
+\n"
+ " locations loc,
+\n"
+ " store_customers sc,
+\n"
+ " product prod
+\n"
+ "WHERE prod.name = 'widget'
+\n"
+ " AND store.loc_id = loc.id
+\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )
+\n"
+ " AND sc.store_id = store.id
+\n"
+ " AND sc.cust_id = cust.id
+\n"
+ " AND prod.id = ALL(
+\n"
+ " SELECT item.prod_id
+\n"
+ " FROM line_items item, orders o
+\n"
+ " WHERE item.order_id = o.id
+\n"
+ " AND cust.current_order = o.id
+\n"
+ " )]]>"
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr "order by節"
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr "クエリãŒè¿”ã™listã¯ã€è¿”ã•ã‚Œã‚‹ã‚¯ãƒ©ã‚¹ã‚„コンãƒãƒ¼ãƒãƒ³ãƒˆã®ä»»æ„ã®å±žæ€§ã«ã‚ˆã£ã¦ä¸¦ã¹æ›¿ãˆã‚‰ã‚Œã¾ã™ã€‚："
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat cat
+\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr "オプション㮠<literal>asc</literal> 㨠<literal>desc</literal> ã¯ãã‚Œãžã‚Œæ˜‡é †ã‹é™é †ã®æ•´åˆ—を示ã—ã¾ã™ã€‚"
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr "group by節"
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr "集約値を返ã™ã‚¯ã‚¨ãƒªã¯ã€è¿”ã•ã‚Œã‚‹ã‚¯ãƒ©ã‚¹ã‚„コンãƒãƒ¼ãƒãƒ³ãƒˆã®ä»»æ„ã®ãƒ—ãƒãƒ‘ティã«ã‚ˆã£ã¦ã‚°ãƒ«ãƒ¼ãƒ—化ã§ãã¾ã™ã€‚:"
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)
+\n"
+ "from Cat cat
+\n"
+ "group by cat.color]]>"
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr ""
+ "<![CDATA[select foo.id, avg(name), max(name)
+\n"
+ "from Foo foo join foo.names name
+\n"
+ "group by foo.id]]>"
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr "<literal>having</literal> 節も使ãˆã¾ã™ã€‚"
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)
+\n"
+ "from Cat cat
+\n"
+ "group by cat.color
+\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr "ã‚‚ã—使用ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒã‚µãƒãƒ¼ãƒˆã—ã¦ã„ã‚‹ãªã‚‰ã€ <literal>having</literal> 㨠<literal>order by</literal> 節ã§SQL関数ã¨é›†ç´„関数ãŒä½¿ãˆã¾ã™ （例ãˆã°MySQLã«ã¯ã‚ã‚Šã¾ã›ã‚“）。"
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+ "<![CDATA[select cat
+\n"
+ "from Cat cat
+\n"
+ " join cat.kittens kitten
+\n"
+ "group by cat
+\n"
+ "having avg(kitten.weight) > 100
+\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr "<literal>group by</literal> 節や <literal>order by</literal> 節㫠算術å¼ã‚’å«ã‚€ã“ã¨ãŒã§ããªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr "副å•ã„åˆã‚ã›"
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr "サブセレクトをサãƒãƒ¼ãƒˆã™ã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ãŸã‚ã€Hibernateã¯å‰¯å•ã„åˆã‚ã›ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ 副å•ã„åˆã‚ã›ã¯æ‹¬å¼§ã§å›²ã¾ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“（SQLã®é›†ç´„関数呼ã³å‡ºã—ã«ã‚ˆã‚‹äº‹ãŒå¤šã„ã§ã™ï¼‰ã€‚ 関連副å•ã„åˆã‚ã›(外部クエリä¸ã®åˆ¥åã‚’å‚ç…§ã™ã‚‹å‰¯å•ã„åˆã‚ã›ã®ã“ã¨)ã•ãˆè¨±å¯ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+ "<![CDATA[from Cat as fatcat
+\n"
+ "where fatcat.weight > (
+\n"
+ " select avg(cat.weight) from DomesticCat cat
+\n"
+ ")]]>"
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat
+\n"
+ "where cat.name = some (
+\n"
+ " select name.nickName from Name as name
+\n"
+ ")]]>"
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ "where not exists (
+\n"
+ " from Cat as mate where mate.mate = cat
+\n"
+ ")]]>"
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat
+\n"
+ "where cat.name not in (
+\n"
+ " select name.nickName from Name as name
+\n"
+ ")]]>"
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)
+\n"
+ "from Cat as cat]]>"
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr "HQL副å•ã„åˆã‚ã›ã¯ã€selectã¾ãŸã¯where節ã ã‘ã§ä½¿ã‚れるã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "selectリストã«è¤‡æ•°ã®å¼ã‚’æŒã¤å‰¯å•ã„åˆã‚ã›ã«ã¯ã€ã‚¿ãƒ—ルを使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat
+\n"
+ "where not ( cat.name, cat.color ) in (
+\n"
+ " select cat.name, cat.color from DomesticCat cat
+\n"
+ ")]]>"
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr "ã„ãã¤ã‹ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ï¼ˆOracleã‚„HSQLã«ã¯ã‚ã‚Šã¾ã›ã‚“）ã§ã¯ã€ ä»–ã®ã‚³ãƒ³ãƒ†ã‚ストã§ã‚‚タプルãŒä½¿ãˆã¾ã™ã€‚ 例ãˆã°ã€ã‚¯ã‚¨ãƒªã‚³ãƒ³ãƒãƒ¼ãƒãƒ³ãƒˆã‚„複åˆãƒ¦ãƒ¼ã‚¶åž‹ã«ãŠã„ã¦ã§ã™ã€‚"
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr "<![CDATA[from Person where name = ('Gavin', 'A', 'King')]]>"
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr "åŒç‰ã§ã™ãŒã€ã‚ˆã‚Šå†—é•·ãªã‚¯ã‚¨ãƒªã§ã™ï¼š"
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr "<![CDATA[from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')]]>"
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr "ã“ã®ã‚ˆã†ãªã“ã¨ã‚’ã—ãŸããªã„ã®ã«ã¯2ã¤ã®ç†ç”±ãŒã‚ã‚Šã¾ã™ï¼š 1ã¤ç›®ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ—ラットフォーム間ã§å®Œå…¨ãªäº’æ›æ€§ã¯ãªã„ã‹ã‚‰ã§ã™ã€‚ 2ã¤ç›®ã¯ã€ã‚¯ã‚¨ãƒªãŒãƒžãƒƒãƒ”ングドã‚ュメントã®ãƒ—ãƒãƒ‘ティã®é †åºã«ä¾å˜ã™ã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr "HQLã®ä¾‹"
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr "Hibernateクエリã¯éžå¸¸ã«å¼·åŠ›ã§è¤‡é›‘ã«ã§ãã¾ã™ã€‚実際ã€ã‚¯ã‚¨ãƒªè¨€èªžã®å¨åŠ›ã¯Hibernateã®ä¸»è¦ãªã‚»ãƒ¼ãƒ«ã‚¹ãƒã‚¤ãƒ³ãƒˆã®ä¸€ã¤ã§ã™ã€‚ ã“ã“ã«æœ€è¿‘ã®ãƒ—ãƒã‚¸ã‚§ã‚¯ãƒˆã§ä½¿ç”¨ã—ãŸã‚¯ã‚¨ãƒªã¨éžå¸¸ã«ã‚ˆãä¼¼ãŸä¾‹ãŒã‚ã‚Šã¾ã™ã€‚ ã»ã¨ã‚“ã©ã®ã‚¯ã‚¨ãƒªã¯ã“れらã®ä¾‹ã‚ˆã‚Šç°¡å˜ã«è¨˜è¿°ã§ãã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„!"
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr "以下ã®ã‚¯ã‚¨ãƒªã¯ç‰¹å®šã®é¡§å®¢ã¨ä¸Žãˆã‚‰ã‚ŒãŸæœ€å°ã®åˆè¨ˆå€¤ã«å¯¾ã™ã‚‹æœªæ‰•ã„注文ã®æ³¨æ–‡ID〠商å“ã®æ•°ã€æ³¨æ–‡ã®åˆè¨ˆã‚’åˆè¨ˆå€¤ã§æ•´åˆ—ã—ã¦è¿”ã—ã¾ã™ã€‚ ä¾¡æ ¼ã‚’æ±ºå®šã™ã‚‹éš›ã€ç¾åœ¨ã®ã‚«ã‚¿ãƒã‚°ã‚’使ã„ã¾ã™ã€‚çµæžœã¨ã—ã¦è¿”ã•ã‚Œã‚‹SQLクエリ㯠<literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> ãŠã‚ˆã³ <literal>PRICE</literal> テーブルã«å¯¾ã—4ã¤ã®å†…部çµåˆã¨ (関連ã—ãªã„)副å•ã„åˆã‚ã›ã‚’æŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)
+\n"
+ "from Order as order
+\n"
+ " join order.lineItems as item
+\n"
+ " join item.product as product,
+\n"
+ " Catalog as catalog
+\n"
+ " join catalog.prices as price
+\n"
+ "where order.paid = false
+\n"
+ " and order.customer = :customer
+\n"
+ " and price.product = product
+\n"
+ " and catalog.effectiveDate < sysdate
+\n"
+ " and catalog.effectiveDate >= all (
+\n"
+ " select cat.effectiveDate
+\n"
+ " from Catalog as cat
+\n"
+ " where cat.effectiveDate < sysdate
+\n"
+ " )
+\n"
+ "group by order
+\n"
+ "having sum(price.amount) > :minAmount
+\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr "何ã¦å·¨å¤§ãªã‚¯ã‚¨ãƒªãªã®ã§ã—ょã†! 普段ç§ã¯å‰¯å•ã„åˆã‚ã›ã‚’ã‚ã¾ã‚Šä½¿ã„ã¾ã›ã‚“。ã—ãŸãŒã£ã¦ç§ã®ã‚¯ã‚¨ãƒªã¯å®Ÿéš›ã«ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚:"
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)
+\n"
+ "from Order as order
+\n"
+ " join order.lineItems as item
+\n"
+ " join item.product as product,
+\n"
+ " Catalog as catalog
+\n"
+ " join catalog.prices as price
+\n"
+ "where order.paid = false
+\n"
+ " and order.customer = :customer
+\n"
+ " and price.product = product
+\n"
+ " and catalog = :currentCatalog
+\n"
+ "group by order
+\n"
+ "having sum(price.amount) > :minAmount
+\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr "次ã®ã‚¯ã‚¨ãƒªã¯å„ステータスã®æ”¯æ‰•ã„æ•°ã‚’æ•°ãˆã¾ã™ã€‚ãŸã ã—ã™ã¹ã¦ã®æ”¯æ‰•ã„ãŒç¾åœ¨ã®åˆ©ç”¨è€…ã«ã‚ˆã‚‹ 最新ã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹å¤‰æ›´ã§ã‚ã‚‹ <literal>AWAITING_APPROVAL</literal> ã§ã‚ã‚‹å ´åˆã‚’除ãã¾ã™ã€‚ ã“ã®ã‚¯ã‚¨ãƒªã¯2ã¤ã®å†…部çµåˆã¨ <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> ãŠã‚ˆã³ <literal>PAYMENT_STATUS_CHANGE</literal> テーブルã«å¯¾ã™ã‚‹é–¢é€£å‰¯å•ã„åˆã‚ã›ã‚’å‚™ãˆãŸSQLクエリã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr ""
+ "<![CDATA[select count(payment), status.name
+\n"
+ "from Payment as payment
+\n"
+ " join payment.currentStatus as status
+\n"
+ " join payment.statusChanges as statusChange
+\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
+\n"
+ " or (
+\n"
+ " statusChange.timeStamp = (
+\n"
+ " select max(change.timeStamp)
+\n"
+ " from PaymentStatusChange change
+\n"
+ " where change.payment = payment
+\n"
+ " )
+\n"
+ " and statusChange.user <> :currentUser
+\n"
+ " )
+\n"
+ "group by status.name, status.sortOrder
+\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr "ã‚‚ã—ç§ãŒsetã®ä»£ã‚ã‚Šã«listã¨ã—㦠<literal>statusChanges</literal> コレクションを マッピングã—ãŸãªã‚‰ã°ã€ã¯ã‚‹ã‹ã«ç°¡å˜ã«ã‚¯ã‚¨ãƒªã‚’記述ã§ãã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr ""
+ "<![CDATA[select count(payment), status.name
+\n"
+ "from Payment as payment
+\n"
+ " join payment.currentStatus as status
+\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
+\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser
+\n"
+ "group by status.name, status.sortOrder
+\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "次ã®ã‚¯ã‚¨ãƒªã¯ç¾åœ¨ã®ãƒ¦ãƒ¼ã‚¶ãŒæ‰€å±žã™ã‚‹çµ„ç¹”ã«å¯¾ã™ã‚‹ã‚¢ã‚«ã‚¦ãƒ³ãƒˆãŠã‚ˆã³æœªæ‰•ã„ã®æ”¯æ‰•ã„ã‚’ ã™ã¹ã¦è¿”ã™MS SQL Server ã® <literal>isNull()</literal> 関数を使用ã—ã¦ã„ã¾ã™ã€‚ ã“ã®ã‚¯ã‚¨ãƒªã¯3ã¤ã®å†…部çµåˆã¨1ã¤ã®å¤–部çµåˆ 〠ãã—㦠<literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> ãŠã‚ˆã³ <literal>ORG_USER</literal> テーブルã«å¯¾ã™ã‚‹å‰¯å•ã„åˆã‚ã›æŒã£ãŸSQLã«å¤‰æ›ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr ""
+ "<![CDATA[select account, payment
+\n"
+ "from Account as account
+\n"
+ " left outer join account.payments as payment
+\n"
+ "where :currentUser in elements(account.holder.users)
+\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
+\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr "ã„ãã¤ã‹ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã¤ã„ã¦ã¯ã€(関連ã•ã›ã‚‰ã‚ŒãŸ)副å•ã„åˆã‚ã›ã®ä½¿ç”¨ã‚’é¿ã‘ã‚‹å¿…è¦ãŒã‚ã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr ""
+ "<![CDATA[select account, payment
+\n"
+ "from Account as account
+\n"
+ " join account.holder.users as user
+\n"
+ " left outer join account.payments as payment
+\n"
+ "where :currentUser = user
+\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
+\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr "大é‡ã®UPDATEã¨DELETE"
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr "HQLã¯ä»Šã¯ <literal>update</literal> 㨠<literal>delete</literal>ã€<literal>insert ... select ...</literal> ステートメントをHQLã«å…¥ã‚Œã‚‹ã“ã¨ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ <xref linkend=\"batch-direct\"/> ã«è©³ç´°ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr "Tips & Tricks"
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr "実際ã«çµæžœã‚’è¿”ã•ãªãã¦ã‚‚クエリã®çµæžœæ•°ã‚’æ•°ãˆã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚:"
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr "コレクションã®ã‚µã‚¤ã‚ºã«ã‚ˆã‚Šçµæžœã‚’並ã¹æ›¿ãˆã‚‹ãŸã‚ã«ã¯ä»¥ä¸‹ã®ã‚¯ã‚¨ãƒªã‚’使用ã—ã¾ã™ã€‚:"
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name
+\n"
+ "from User as usr
+\n"
+ " left join usr.messages as msg
+\n"
+ "group by usr.id, usr.name
+\n"
+ "order by count(msg)]]>"
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr "使用ã—ã¦ã„るデータベースãŒã‚µãƒ–セレクトをサãƒãƒ¼ãƒˆã™ã‚‹å ´åˆã€ã‚¯ã‚¨ãƒªã®where節ã§ã‚µã‚¤ã‚ºã«ã‚ˆã‚‹é¸æŠžæ¡ä»¶ã‚’è¨å®šã§ãã¾ã™:"
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr "使用ã—ã¦ã„るデータベースãŒã‚µãƒ–セレクトをサãƒãƒ¼ãƒˆã—ãªã„å ´åˆã¯ã€æ¬¡ã®ã‚¯ã‚¨ãƒªã‚’使用ã—ã¦ãã ã•ã„:"
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name
+\n"
+ "from User usr.name
+\n"
+ " join usr.messages msg
+\n"
+ "group by usr.id, usr.name
+\n"
+ "having count(msg) >= 1]]>"
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr "内部çµåˆã‚’ã—ã¦ã„ã‚‹ã›ã„ã§ä¸Šã®è§£æ±ºæ³•ãŒmessageã®ä»¶æ•°ãŒ ゼãƒã® <literal>User</literal> ã‚’è¿”ã™ã“ã¨ãŒã§ããªã„ãªã‚‰ã°ã€ä»¥ä¸‹ã®å½¢å¼ãŒä½¿ãˆã¾ã™ã€‚"
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name
+\n"
+ "from User as usr
+\n"
+ " left join usr.messages as msg
+\n"
+ "group by usr.id, usr.name
+\n"
+ "having count(msg) = 0]]>"
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr "JavaBeanã®ãƒ—ãƒãƒ‘ティã¯ã€åå‰ä»˜ãã®ã‚¯ã‚¨ãƒªãƒ‘ラメータã«çµã³ã¤ã‘ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚："
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");
+\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()
+\n"
+ "List foos = q.list();]]>"
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr "コレクションã¯ãƒ•ã‚£ãƒ«ã‚¿ä»˜ã <literal>Query</literal> インターフェイスを使用ã™ã‚‹ã“ã¨ã§ãƒšãƒ¼ã‚¸ã‚’ã¤ã‘ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚:"
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter
+\n"
+ "q.setMaxResults(PAGE_SIZE);
+\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);
+\n"
+ "List page = q.list();]]>"
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr "コレクションã®è¦ç´ ã¯ã‚¯ã‚¨ãƒªãƒ•ã‚£ãƒ«ã‚¿ã‚’使ã£ã¦ã€ä¸¦ã¹æ›¿ãˆã‚„グループ分ã‘ãŒå‡ºæ¥ã¾ã™ã€‚:"
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );
+\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr "コレクションをåˆæœŸåŒ–ã›ãšã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚µã‚¤ã‚ºã‚’å¾—ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚:"
+
+#: index.docbook:985
+msgid "Components"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr ""
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr ""
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr ""
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr ""
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr ""
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr ""
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr ""
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr ""
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr ""
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1044 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr "ãƒã‚¤ãƒ†ã‚£ãƒ–SQL"
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr "データベースã®ãƒã‚¤ãƒ†ã‚£ãƒ–SQL方言を使ã£ã¦ã‚¯ã‚¨ãƒªã‚’表ç¾ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ クエリヒントやOracleã® <literal>CONNECT</literal> ã‚ーワードã®ã‚ˆã†ã«ã€ データベース独自ã®æ©Ÿèƒ½ã‚’利用ã—ãŸã„ã¨ãã«ä½¿ãˆã¾ã™ã€‚ SQL/JDBCを直接使用ã—ã¦ã„るアプリケーションã‹ã‚‰Hibernateã¸ã®ç§»è¡Œã‚‚容易ã«ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr "Hibernate3ã§ã¯ã€ç”Ÿæˆã€æ›´æ–°ã€å‰Šé™¤ã€èªã¿è¾¼ã¿å‡¦ç†ã®ã‚ˆã†ãªã™ã¹ã¦ã® SQL（ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’å«ã‚€ï¼‰ã‚’手書ãã§ãã¾ã™ã€‚"
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr "<literal>SQLQuery</literal> ã®ä½¿ç”¨"
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr "ãƒã‚¤ãƒ†ã‚£ãƒ–ãªSQLクエリã®å®Ÿè¡Œã¯ <literal>SQLQuery</literal> インターフェイスを通ã—ã¦åˆ¶å¾¡ã—ã¾ã™ã€‚ <literal>SQLQuery</literal> インターフェイス㯠<literal>Session.createSQLQuery()</literal> を呼ã³å‡ºã—ã¦å–å¾—ã—ã¾ã™ã€‚ ã“ã®APIを使ã£ã¦å•ã„åˆã‚ã›ã™ã‚‹æ–¹æ³•ã‚’以下ã§èª¬æ˜Žã—ã¾ã™ã€‚"
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr "スカラーã®ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr "最も基本的ãªSQLクエリã¯ã‚¹ã‚«ãƒ©ãƒ¼ï¼ˆå€¤ï¼‰ã®ãƒªã‚¹ãƒˆã‚’å¾—ã‚‹ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr "ã“れらã¯ã©ã¡ã‚‰ã‚‚ã€CATSテーブルã®å„カラムã®ã‚¹ã‚«ãƒ©ãƒ¼å€¤ã‚’å«ã‚€ Objecté…列（Object[]）ã®ãƒªã‚¹ãƒˆã‚’è¿”ã—ã¾ã™ã€‚ è¿”ã™ã‚¹ã‚«ãƒ©ãƒ¼å€¤ã®å®Ÿéš›ã®é †ç•ªã¨åž‹ã‚’推定ã™ã‚‹ãŸã‚ã«ã€ Hibernateã¯ResultSetMetadataを使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr "<literal>ResultSetMetadata</literal> を使用ã™ã‚‹ã‚ªãƒ¼ãƒãƒ¼ãƒ˜ãƒƒãƒ‰ã‚’é¿ã‘ã‚‹ãŸã‚〠もã—ãã¯å˜ã«ä½•ãŒè¿”ã•ã‚Œã‚‹ã‹æ˜Žç¢ºã«ã™ã‚‹ãŸã‚ã€<literal>addScalar()</literal> を使ãˆã¾ã™ã€‚"
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã§æŒ‡å®šã•ã‚Œã¦ã„ã‚‹ã‚‚ã®ã‚’下記ã«ç¤ºã—ã¾ã™ã€‚"
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr "SQLクエリ文å—列"
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr "è¿”ã•ã‚Œã‚‹ã‚«ãƒ©ãƒ ã¨åž‹"
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr "ã“ã‚Œã¯ã¾ã Objecté…列を返ã—ã¾ã™ãŒã€ <literal>ResultSetMetdata</literal> を使用ã—ã¾ã›ã‚“。 ãŸã ã—ã€ãã®ä»£ã‚ã‚Šã«åŸºç¤Žã«ã‚るリザルトセットã‹ã‚‰ IDã€NAMEã€BIRTHDATE カラムをãã‚Œãžã‚Œ Longã€Stringã€Short ã¨ã—ã¦æ˜Žç¤ºçš„ã«å–å¾—ã—ã¾ã™ã€‚ ã“ã‚Œã¯ï¼“ã¤ã®ã‚«ãƒ©ãƒ ã‚’è¿”ã™ã®ã¿ã§ã‚ã‚‹ã“ã¨ã‚‚æ„味ã—ã¾ã™ã€‚ ãŸã¨ãˆã€ã‚¯ã‚¨ãƒªãŒ <literal>*</literal> を使用ã—〠列挙ã—ãŸï¼“ã¤ã‚ˆã‚Šå¤šãã®ã‚«ãƒ©ãƒ ã‚’è¿”ã›ã‚‹ã¨ã—ã¦ã‚‚ã§ã™ã€‚"
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr "スカラーã®åž‹æƒ…å ±ã‚’çœãã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr "ã“ã‚Œã¯æœ¬è³ªçš„ã«å‰ã¨åŒã˜ã‚¯ã‚¨ãƒªã§ã™ãŒã€ã€ NAME 㨠BIRTHDATE ã®åž‹ã‚’決ã‚ã‚‹ãŸã‚ã« <literal>ResultSetMetaData</literal> を使用ã—ã¾ã™ã€‚一方ã€ID ã®åž‹ã¯æ˜Žç¤ºçš„ã«æŒ‡å®šã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr "ResultSetMetaData ã‹ã‚‰è¿”ã•ã‚Œã‚‹ java.sql.Types ã‚’ Hibernate ã®åž‹ã« マッピングã™ã‚‹ã“ã¨ã¯ã€Dialect ãŒåˆ¶å¾¡ã—ã¾ã™ã€‚ 明示ã•ã‚ŒãŸåž‹ãŒãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ãªã„ã‹ã€çµæžœã®åž‹ãŒæœŸå¾…ã—ãŸã‚‚ã®ã¨ç•°ãªã‚‹å ´åˆã€ Dialect ã® <literal>registerHibernateType</literal> を呼ã³å‡ºã—〠カスタマイズã§ãã¾ã™ã€‚"
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr "エンティティã®ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr "ã“ã“ã¾ã§ã®ã‚¯ã‚¨ãƒªã¯ã€ã™ã¹ã¦ã‚¹ã‚«ãƒ©ãƒ¼å€¤ã‚’è¿”ã™ã‚‚ã®ã§ã—ãŸã€‚ 基本的ã«ã€ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‹ã‚‰ã€ŒæœªåŠ å·¥ã€ã®å€¤ã‚’è¿”ã—ã¾ã™ã€‚ 以é™ã§ã¯ã€<literal>addEntity()</literal> ã«ã‚ˆã‚Šã€ãƒã‚¤ãƒ†ã‚£ãƒ–SQLクエリã‹ã‚‰ エンティティオブジェクトをå–å¾—ã™ã‚‹æ–¹æ³•ã‚’示ã—ã¾ã™ã€‚"
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr "クエリãŒè¿”ã™ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨SQLテーブルã®åˆ¥å"
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr "CatãŒID, NAME, BIRTHDATEã®ã‚«ãƒ©ãƒ を使ã£ã¦ã‚¯ãƒ©ã‚¹ã«ãƒžãƒƒãƒ”ングã•ã‚Œã‚‹å ´åˆã€ 上記ã®ã‚¯ã‚¨ãƒªã¯ã©ã¡ã‚‰ã‚‚ã€è¦ç´ ãŒCatエンティティã§ã‚るリストを返ã—ã¾ã™ã€‚"
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr "エンティティを別ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã« <literal>多対一</literal> ã§ãƒžãƒƒãƒ”ングã—ã¦ã„ã‚‹å ´åˆã¯ã€ ãƒã‚¤ãƒ†ã‚£ãƒ–クエリを実行ã™ã‚‹éš›ã«ã€ã“ã®åˆ¥ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’è¿”ã™ã“ã¨ã‚‚è¦æ±‚ã—ã¾ã™ã€‚ ã•ã‚‚ãªã‘ã‚Œã°ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å›ºæœ‰ã®ã€Œcolumn not found(カラムãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“)ã€ã‚¨ãƒ©ãƒ¼ãŒç™ºç”Ÿã—ã¾ã™ã€‚ * 表記を使用ã—ãŸéš›ã¯ã€è¿½åŠ ã®ã‚«ãƒ©ãƒ ãŒè‡ªå‹•çš„ã«è¿”ã•ã‚Œã¾ã™ãŒã€ 次ã®ä¾‹ã®ã‚ˆã†ã«ã€<literal>Dog</literal> ã« <literal>多対一</literal> ã§ã‚ã‚‹ã“ã¨ã‚’ 明示ã™ã‚‹ã“ã¨ã‚’ç§ãŸã¡ã¯å¥½ã¿ã¾ã™ã€‚"
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr "ã“ã‚Œã«ã‚ˆã‚Š cat.getDog() ãŒæ£ã—ã機能ã—ã¾ã™ã€‚"
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr "関連ã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®æ“作"
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr "プãƒã‚ã‚·ã‚’åˆæœŸåŒ–ã™ã‚‹ãŸã‚ã®ä½™åˆ†ãªå‡¦ç†ã‚’é¿ã‘ã‚‹ãŸã‚〠<literal>Dog</literal> ã®ä¸ã§å³æ™‚çµåˆã§ãã¾ã™ã€‚ ã“れ㯠<literal>addJoin()</literal> メソッドã«ã‚ˆã‚Šè¡Œã„ã¾ã™ã€‚ 関連もã—ãã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«çµåˆã§ãã¾ã™ã€‚"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr "ã“ã®ä¾‹ã®ä¸ã§ã€è¿”ã•ã‚Œã‚‹ <literal>Cat</literal> ã¯ã€ データベースã¸ã®ä½™åˆ†å‡¦ç†ãªã—ã§ã€ 完全ã«åˆæœŸåŒ–ã•ã‚ŒãŸ <literal>dog</literal> プãƒãƒ‘ティをæŒã¡ã¾ã™ã€‚ çµåˆå¯¾è±¡ã®ãƒ—ãƒãƒ‘ティã¸ã®ãƒ‘スを指定ã§ãるよã†ã«ã€ 別å（「catã€ï¼‰ã‚’è¿½åŠ ã—ãŸã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 コレクションã®å³æ™‚çµåˆã‚‚åŒã˜ã‚ˆã†ã«ã§ãã¾ã™ã€‚ ãŸã¨ãˆã°ã€<literal>Cat</literal> ãŒä¸€å¯¾å¤šã§ <literal>Dog</literal> ã‚’æŒã£ã¦ã„ãŸå ´åˆã€æ¬¡ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr "ç¾åœ¨ã®ã¨ã“ã‚〠Hibernateã§ä½¿ã„ã‚„ã™ãã™ã‚‹ãŸã‚ã®SQLクエリã®æ‹¡å¼µãªã—ã«ã€ ãƒã‚¤ãƒ†ã‚£ãƒ–クエリã§ä½•ã‹ã‚’å¯èƒ½ã«ã™ã‚‹é™ç•Œã«æ¥ã¦ã„ã¾ã™ã€‚ åŒã˜åž‹ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’複数返ã™éš›ã‚„ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®åˆ¥åや列åã§å分ã§ã¯ãªã„å ´åˆã«ã€ å•é¡Œã¯èµ·ã“り始ã‚ã¾ã™ã€‚"
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr "複数エンティティã®å–å¾—"
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr "ã“ã“ã¾ã§ã¯ã€ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã®ã‚«ãƒ©ãƒ åã¯ã€ マッピングファイルã§æŒ‡å®šã•ã‚ŒãŸã‚«ãƒ©ãƒ åã¨åŒã˜ã§ã‚ã‚‹ã¨ä»®å®šã—ã¦ã„ã¾ã—ãŸã€‚ 複数ã®ãƒ†ãƒ¼ãƒ–ルãŒåŒã˜ã‚«ãƒ©ãƒ åã‚’æŒã¤å ´åˆãŒã‚ã‚‹ãŸã‚〠複数テーブルをçµåˆã™ã‚‹SQLクエリã§å•é¡Œã¨ãªã‚‹å ´åˆãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr "下記ã®ã‚ˆã†ãªï¼ˆå¤±æ•—ã—ãã†ãªï¼‰ã‚¯ã‚¨ãƒªã§ã¯ã€ カラム別åインジェクション（column alias injection）ãŒå¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = m.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr "ã“ã®ã‚¯ã‚¨ãƒªã®æ„図ã¯ã€ １行ã”ã¨ã«ï¼’ã¤ã®Catインスタンスã€ã¤ã¾ã‚ŠçŒ«ã¨ãã®æ¯è¦ªã‚’è¿”ã™ã¨ã„ã†ã“ã¨ã§ã™ã€‚ åŒã˜ã‚«ãƒ©ãƒ åã«ãƒžãƒƒãƒ”ングã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šåå‰ãŒè¡çªã™ã‚‹ãŸã‚ã€ã“ã®ã‚¯ã‚¨ãƒªã¯å¤±æ•—ã—ã¾ã™ã€‚ ベータベースã«ã‚ˆã£ã¦ã¯ã€è¿”ã•ã‚Œã‚‹ã‚«ãƒ©ãƒ ã®åˆ¥å㌠\"c.ID\"ã€\"c.NAME\" ãªã©ã®å½¢å¼ã§ã‚り〠マッピングã§æŒ‡å®šã•ã‚ŒãŸã‚«ãƒ©ãƒ （\"ID\" 㨠\"NAME\"）ã¨ç‰ã—ããªã„ãŸã‚ã€å¤±æ•—ã—ã¾ã™ã€‚"
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr "下記ã®å½¢å¼ã¯ã€ã‚«ãƒ©ãƒ åãŒé‡è¤‡ã—ã¦ã‚‚大丈夫ã§ã™ã€‚"
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = m.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr "SQLクエリ文å—列 （HibernateãŒã‚«ãƒ©ãƒ ã®åˆ¥åを挿入ã™ã‚‹ãŸã‚ã®ãƒ—レースホルダをå«ã‚€ï¼‰"
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr "クエリã«ã‚ˆã£ã¦è¿”ã•ã‚Œã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£"
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr "上記ã§ä½¿ç”¨ã—ã¦ã„ã‚‹ {cat.*} 㨠{mother.*} ã¨ã„ã†è¡¨è¨˜ã¯ã€ 「ã™ã¹ã¦ã®ãƒ—ãƒãƒ‘ティã€ã‚’表ã™çœç•¥å½¢ã§ã™ã€‚ 代ã‚ã‚Šã«ã€æ˜Žç¤ºçš„ã«ã‚«ãƒ©ãƒ を列挙ã—ã¦ã‚‚よã„ã§ã™ãŒã€ ãã®å ´åˆã¯ã€Hibernateã«å„プãƒãƒ‘ティã«å¯¾å¿œã™ã‚‹SQLカラムã®åˆ¥åを挿入ã•ã›ã‚‹ã¹ãã§ã—ょã†ã€‚ カラムã®åˆ¥åã®ãŸã‚ã®ãƒ—レースホルダã¯ã€ãƒ†ãƒ¼ãƒ–ルã®åˆ¥åã«ã‚ˆã£ã¦ä¿®é£¾ã•ã‚ŒãŸãƒ—ãƒãƒ‘ティåã§ã™ã€‚ 下記ã®ä¾‹ã§ã¯ã€åˆ¥ã®ãƒ†ãƒ¼ãƒ–ル cat_log ã‹ã‚‰ マッピングメタデータã§å®šç¾©ã•ã‚ŒãŸ Cat ã¨ãã®æ¯è¦ªã‚’復元ã—ã¾ã™ã€‚ ã‚‚ã—好むãªã‚‰ã€where節ã®ä¸ã§ã‚‚ã€ãƒ—ãƒãƒ‘ティã®åˆ¥åを使ãˆã¾ã™ã€‚"
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr "別åã¨ãƒ—ãƒãƒ‘ティã®ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹"
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr "多ãã®å ´åˆã€ä¸Šè¨˜ã®ã‚ˆã†ãªåˆ¥åインジェクションãŒå¿…è¦ã§ã™ã€‚ ãŸã ã—ã€è¤‡åˆãƒ—ãƒãƒ‘ティã€ç¶™æ‰¿è˜åˆ¥åã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãªã©ã®ã‚ˆã†ãª より複雑ãªãƒžãƒƒãƒ”ングã¨é–¢é€£ã™ã‚‹ã‚¯ã‚¨ãƒªãŒãªã‘ã‚Œã°ã§ã™ã€‚ ã‚る特定ã®åˆ¥åを使用ã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šã€Hibernateã¯é©åˆ‡ãªåˆ¥åを挿入ã§ãã¾ã™ã€‚"
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr "別åインジェクションã¨ã—ã¦ä½¿ç”¨ã§ãã‚‹ã‚‚ã®ã‚’下表ã«ç¤ºã—ã¾ã™ã€‚ 注æ„：下表ã®åˆ¥åã¯ä¸€ä¾‹ã§ã™ã€‚ ãã‚Œãžã‚Œã®åˆ¥åã¯ä¸€æ„ã§ã‚ã‚Šã€ä½¿ç”¨ã™ã‚‹éš›ã«ã¯ãŠãらãç•°ãªã‚‹åå‰ã‚’æŒã¡ã¾ã™ã€‚"
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr "別åã«æŒ¿å…¥ã™ã‚‹åå‰"
+
+#: index.docbook:219
+msgid "Description"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr "<entry>構文</entry>"
+
+#: index.docbook:223
+msgid "Example"
+msgstr "<entry>例</entry>"
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr "å˜ç´”ãªãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr "{[aliasname].[propertyname]}"
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr "A_NAME as {item.name}"
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr "複åˆãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr "{[aliasname].[componentname].[propertyname]}"
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr "エンティティã®ã‚¯ãƒ©ã‚¹ã‚’è˜åˆ¥ã™ã‚‹å€¤"
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr "{[aliasname].class}"
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr "DISC as {item.class}"
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr "エンティティã®å…¨ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr "{[aliasname].*}"
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr "{item.*}"
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr "コレクションã®ã‚ー"
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr "{[aliasname].key}"
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr "ORGID as {coll.key}"
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr "コレクションã®ID"
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr "{[aliasname].id}"
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr "EMPID as {coll.id}"
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr "コレクションã®è¦ç´ "
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr "{[aliasname].element}"
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr "XID as {coll.element}"
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr "コレクションã®è¦ç´ ã®ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr "{[aliasname].element.[propertyname]}"
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr "NAME as {coll.element.name}"
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr "コレクションã®è¦ç´ ã®å…¨ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr "{[aliasname].element.*}"
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr "{coll.element.*}"
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr "コレクションã®å…¨ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr "{coll.*}"
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr "管ç†ã•ã‚Œã¦ã„ãªã„エンティティã®å–å¾—"
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr "ãƒã‚¤ãƒ†ã‚£ãƒ–SQLクエリ㫠ResultTransformer ã‚’é©ç”¨ã§ãã¾ã™ã€‚ 下記ã®ã‚ˆã†ã«ã€ä¾‹ãˆã°ã€ç®¡ç†ã•ã‚Œã¦ã„ãªã„エンティティを返ã—ã¾ã™ã€‚"
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr "çµæžœã‚’変æ›ã—ãŸã‚‚ã®"
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr "上記ã®ã‚¯ã‚¨ãƒªã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹åŒ–ã—ã€NAME 㨠BIRTHDATE ã®å€¤ã‚’ 対応ã™ã‚‹ãƒ—ãƒãƒ‘ティもã—ãã¯ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã«æŒ¿å…¥ã—㟠<literal>CatDTO</literal> ã®ãƒªã‚¹ãƒˆã‚’è¿”ã—ã¾ã™ã€‚"
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr "継承ã®åˆ¶å¾¡"
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr "継承ã®ä¸€éƒ¨ã¨ã—ã¦ãƒžãƒƒãƒ”ングã•ã‚ŒãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’å•ã„åˆã‚ã›ã‚‹ãƒã‚¤ãƒ†ã‚£ãƒ–SQLクエリã¯ã€ ベースã®ã‚¯ãƒ©ã‚¹ã¨ãã®ã™ã¹ã¦ã®ã‚µãƒ–クラスã®ãƒ—ãƒãƒ‘ティã™ã¹ã¦ã‚’å«ã¾ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr "パラメータ"
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr "ãƒã‚¤ãƒ†ã‚£ãƒ–SQLクエリã¯ã€ä»¥ä¸‹ã®ã‚ˆã†ã«ã€ åå‰ä»˜ãパラメータ（:name）ã¨åŒæ§˜ã«ä½ç½®ãƒ‘ラメータをサãƒãƒ¼ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr "åå‰ä»˜ãSQLクエリ"
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr "åå‰ä»˜ãSQLクエリã¯ãƒžãƒƒãƒ”ングドã‚ュメントã§å®šç¾©ã™ã‚‹ã“ã¨ãŒã§ã〠åå‰ä»˜ãHQLクエリã¨å…¨ãåŒã˜æ–¹æ³•ã§å‘¼ã¶ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã®å ´åˆã€<literal>addEntity()</literal> を呼ã³å‡ºã™å¿…è¦ã¯ <emphasis>ãªã„</emphasis> ã§ã™ã€‚"
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr "関連をçµåˆã™ã‚‹ãŸã‚ã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’åˆæœŸåŒ–ã™ã‚‹ã‚¯ã‚¨ãƒªã‚’定義ã™ã‚‹ãŸã‚ã«ã€ãã‚Œãžã‚Œ <literal><return-join></literal> 㨠<literal><load-collection></literal> è¦ç´ を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr "åå‰ä»˜ãSQLクエリã¯ã‚¹ã‚«ãƒ©å€¤ã‚’è¿”ã™ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ <literal><return-scalar></literal> è¦ç´ を使ã£ã¦ã€ 列ã®åˆ¥åã¨Hibernateã®åž‹ã‚’宣言ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr "リザルトセットã®ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã‚’ <literal><resultset></literal> ã«å¤–出ã—ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ 複数ã®åå‰ä»˜ãクエリã§å†åˆ©ç”¨ã—ãŸã‚Šã€<literal>setResultSetMapping()</literal> APIを通ã—ã¦å†åˆ©ç”¨ã—ãŸã‚Šã§ãã¾ã™ã€‚"
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr "代ã‚ã‚Šã«ã€hbmファイル内ã®ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã®ãƒžãƒƒãƒ”ãƒ³ã‚°æƒ…å ±ã‚’ 直接Javaコードã®ä¸ã§ä½¿ç”¨ã§ãã¾ã™ã€‚"
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr "列ã¨åˆ—ã®åˆ¥åを明示的ã«æŒ‡å®šã™ã‚‹ãŸã‚ã« return-property を使ã†"
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr "別åを挿入ã™ã‚‹ãŸã‚ã« <literal>{}</literal> 構文を使ã†ä»£ã‚ã‚Šã«ã€ <literal><return-property></literal> を使ã„〠ã©ã®åˆ—ã®åˆ¥åを使ã†ã®ã‹ã‚’明示ã§ãã¾ã™ã€‚"
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr "<literal><return-property></literal> ã¯è¤‡æ•°ã®åˆ—も扱ãˆã¾ã™ã€‚ ã“ã‚Œã¯ã€è¤‡æ•°åˆ—ã®ãƒ—ãƒãƒ‘ティをãã‚ç´°ã‹ã制御ã§ããªã„ã¨ã„ã†ã€ <literal>{}</literal> 構文ã®åˆ¶é™ã‚’解決ã—ã¾ã™ã€‚"
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr "ã“ã®ä¾‹ã§ã¯ã€æŒ¿å…¥ã®ãŸã‚ã® <literal>{}</literal> 構文ã¨ã„ã£ã—ょã«ã€ <literal><return-property></literal> を使ã£ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 列ã¨ãƒ—ãƒãƒ‘ティをã©ã®ã‚ˆã†ã«å‚ç…§ã™ã‚‹ã‹ã‚’é¸ã¹ã¾ã™ã€‚"
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr "マッピング㫠discriminator ãŒå«ã¾ã‚Œã¦ã„ã‚‹å ´åˆã€ discriminator ã®åˆ—を指定ã™ã‚‹ãŸã‚ã«ã€<return-discriminator> を使ã‚ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr "å•ã„åˆã‚ã›ã™ã‚‹ãŸã‚ã«ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’使ã†"
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr "Hibernateã¯ãƒãƒ¼ã‚¸ãƒ§ãƒ³3ã‹ã‚‰ã€ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã¨ã‚¹ãƒˆã‚¢ãƒ‰é–¢æ•°çµŒç”±ã®å•ã„åˆã‚ã›ãŒ サãƒãƒ¼ãƒˆã•ã‚Œã¾ã—ãŸã€‚ 以é™ã®æ–‡æ›¸ã®å¤šãã¯ã€ä¸¡æ–¹ã«å½“ã¦ã¯ã¾ã‚Šã¾ã™ã€‚ ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚„ストアド関数をHibernateã§ä½¿ã†ãŸã‚ã«ã¯ã€ 1番目ã®å‡ºåŠ›ãƒ‘ラメータã¨ã—ã¦ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’è¿”ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 Oracle 9（もã—ãã¯ãれ以上ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ï¼‰ã®ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã®ä¾‹ã‚’以下ã«ç¤ºã—ã¾ã™ã€‚"
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr "Hibernateã§ã“ã®ã‚¯ã‚¨ãƒªã‚’使ã†ãŸã‚ã«ã¯ã€ åå‰ä»˜ãクエリã§ãƒžãƒƒãƒ”ングã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr "注æ„：今ã®ã¨ã“ã‚ã€ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã¯ã‚¹ã‚«ãƒ©ã¨ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’è¿”ã™ã®ã¿ã§ã™ã€‚ <literal><return-join></literal> 㨠<literal><load-collection></literal> ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr "ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’使ã†ä¸Šã§ã®ãƒ«ãƒ¼ãƒ«ã¨åˆ¶é™"
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr "Hibernateã§ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚„関数を使ã†ãŸã‚ã«ã¯ã€ ãã®ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã¯ã„ãã¤ã‹ã®ãƒ«ãƒ¼ãƒ«ã«æº–æ‹ ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ルールã«æº–æ‹ ã—ã¦ã„ãªã„プãƒã‚·ãƒ¼ã‚¸ãƒ£ã¯ã€Hibernateã§ä½¿ã†ã“ã¨ã¯ã§ãã¾ã›ã‚“。 ãã‚Œã§ã‚‚ã€æº–æ‹ ã—ã¦ã„ãªã„プãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’使ã„ãŸã„ã®ã§ã‚ã‚Œã°ã€ <literal>session.connection()</literal> を通ã˜ã¦å®Ÿè¡Œã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ルールã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã”ã¨ã«ç•°ãªã‚Šã¾ã™ã€‚ ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã®ã‚»ãƒžãƒ³ãƒ†ã‚£ãƒƒã‚¯ã‚¹ã¨ã‚·ãƒ³ã‚¿ãƒƒã‚¯ã‚¹ã¯ã€ データベースベンダã”ã¨ã«ç•°ãªã‚‹ãŸã‚ã§ã™ã€‚"
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr "<literal>setFirstResult()/setMaxResults()</literal> を使ã£ã¦ã€ ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚¯ã‚¨ãƒªã‚’ページ分ã‘ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。"
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr "推奨ã™ã‚‹å‘¼ã³å‡ºã—æ–¹ã¯ã€æ¨™æº–ã§ã‚ã‚‹SQL92ã«å¾“ã†ã“ã¨ã§ã™ã€‚ <literal>{ ? = call functionName(<parameters>) }</literal> ã‚„ <literal>{ ? = call procedureName(<parameters>) }</literal> ã§ã™ã€‚ ãƒã‚¤ãƒ†ã‚£ãƒ–ãªå‘¼ã³å‡ºã—構文ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。"
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr "Oracleã«ã¯ä¸‹è¨˜ã®ãƒ«ãƒ¼ãƒ«ãŒé©ç”¨ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr "関数ã¯ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’è¿”ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 プãƒã‚·ãƒ¼ã‚¸ãƒ£ã®ç¬¬ä¸€å¼•æ•°ã¯ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’è¿”ã™ãŸã‚〠<literal>OUT</literal> ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 Oracle 9ã¨10ã§ã¯ã€<literal>SYS_REFCURSOR</literal> を使ã†ã“ã¨ã«ã‚ˆã£ã¦ã§ãã¾ã™ã€‚ Oracleã§ã¯ <literal>REF CURSOR</literal> 型を定義ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ Oracleã®æ–‡çŒ®ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr "Sybaseã¨MS SQLサーãƒãƒ¼ã«é©ç”¨ã•ã‚Œã‚‹ãƒ«ãƒ¼ãƒ«ã‚’下記ã«ç¤ºã—ã¾ã™ã€‚"
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr "プãƒã‚·ãƒ¼ã‚¸ãƒ£ã¯ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’è¿”ã•ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 サーãƒãƒ¼ã¯è¤‡æ•°ã®ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã¨æ›´æ–°ã‚«ã‚¦ãƒ³ãƒˆã‚’è¿”ã—ã¾ã™ãŒã€ Hibernateã¯1ã¤ç›®ã®ãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã ã‘ã‚’è¿”ã™ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ãã®ä»–ã¯ã™ã¹ã¦æ¨ã¦ã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr "プãƒã‚·ãƒ¼ã‚¸ãƒ£ã®ä¸ã§ <literal>SET NOCOUNT ON</literal> を有効ã«ã§ãã‚Œã°ã€ ãŠãらã効率ãŒã‚ˆããªã‚‹ã§ã—ょã†ã€‚ ã—ã‹ã—ã€ã“ã‚Œã¯å¿…è¦æ¡ä»¶ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr "作æˆã€æ›´æ–°ã€å‰Šé™¤ã®ãŸã‚ã®ã‚«ã‚¹ã‚¿ãƒ SQL"
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr "Hibernate3ã¯ä½œæˆã€æ›´æ–°ã€å‰Šé™¤å‡¦ç†ã®ãŸã‚ã®ã‚«ã‚¹ã‚¿ãƒ SQL文を使用ã§ãã¾ã™ã€‚ クラスã¨ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®æ°¸ç¶šåŒ–機構ã¯ã€ã‚³ãƒ³ãƒ•ã‚£ã‚°ãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³æ™‚ã«ç”Ÿæˆã•ã‚ŒãŸæ–‡å—列 （insertsqlã€deletesqlã€updatesqlãªã©ï¼‰ã®ã‚»ãƒƒãƒˆã‚’ã™ã§ã«ä¿æŒã—ã¦ã„ã¾ã™ã€‚ ã“れらã®æ–‡å—列より〠<literal><sql-insert></literal>〠<literal><sql-delete></literal>〠<literal><sql-update></literal> ã¨ã„ã†ãƒžãƒƒãƒ”ングタグãŒå„ªå…ˆã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr "SQLを直接データベースã§å®Ÿè¡Œã™ã‚‹ãŸã‚ã€å¥½ã¿ã®æ–¹è¨€ã‚’自由ã«ä½¿ç”¨ã§ãã¾ã™ã€‚ データベース独自ã®SQLを使ãˆã°ã€å½“然マッピングã®ãƒãƒ¼ã‚¿ãƒ“リティãŒä¸‹ãŒã‚Šã¾ã™ã€‚"
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr "<literal>callable</literal> 属性をセットã™ã‚Œã°ã€ ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’使用ã§ãã¾ã™ã€‚"
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr "今ã®ã¨ã“ã‚ã€ä½ç½®ãƒ‘ラメータã®é †ç•ªã¯ã¨ã¦ã‚‚é‡è¦ã§ã™ã€‚ ã™ãªã‚ã¡ã€HibernateãŒæœŸå¾…ã™ã‚‹é †åºã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr "<literal>org.hiberante.persister.entity</literal> レベルã®ãƒ‡ãƒãƒƒã‚°ãƒã‚°ã‚’ 有効ã«ã™ã‚‹ã“ã¨ã«ã‚ˆã£ã¦ã€æœŸå¾…ã•ã‚Œã‚‹é †ç•ªã‚’確ã‹ã‚られã¾ã™ã€‚ ã“ã®ãƒ¬ãƒ™ãƒ«ã‚’有効ã«ã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ä½œæˆã€æ›´æ–°ã€å‰Šé™¤ãªã©ã§ 使用ã•ã‚Œã‚‹é™çš„ãªSQLãŒå‡ºåŠ›ã•ã‚Œã¾ã™ã€‚ （期待ã•ã‚Œã‚‹é †åºã‚’確èªã™ã‚‹ãŸã‚ã«ã¯ã€HibernateãŒç”Ÿæˆã™ã‚‹é™çš„ãªSQLをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã™ã‚‹ カスタムSQLをマッピングファイルã«å«ã‚ãªã„ã“ã¨ã‚’忘れãªã„ã§ãã ã•ã„。）"
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr "ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã¯æŒ¿å…¥/æ›´æ–°/削除ã•ã‚ŒãŸè¡Œæ•°ã‚’è¿”ã™å¿…è¦ãŒã‚ã‚Šã¾ã™ （èªã¿è¾¼ã¿ã®å ´åˆã¯ã€è¿”ã•ãªã„よりã¯è¿”ã™æ–¹ãŒã‚ˆã„ã§ã™ï¼‰ã€‚ 実行時ã«HibernateãŒSQLæ–‡ã®æˆåŠŸã‚’ãƒã‚§ãƒƒã‚¯ã™ã‚‹ã‹ã‚‰ã§ã™ã€‚ Hibernateã¯ã€CUD処ç†ã®ãŸã‚ã®æ•°å€¤ã®å‡ºåŠ›ãƒ‘ラメータã¨ã—ã¦ã€ SQLæ–‡ã®æœ€åˆã®ãƒ‘ラメータをã„ã¤ã‚‚記録ã—ã¾ã™ã€‚"
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr "ãƒãƒ¼ãƒ‰ã®ãŸã‚ã®ã‚«ã‚¹ã‚¿ãƒ SQL"
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr "エンティティをèªã¿è¾¼ã‚€ãŸã‚ã®ç‹¬è‡ªã®SQL（もã—ãã¯HQL）クエリも宣言ã§ãã¾ã™ã€‚"
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr "ã“ã‚Œã¯ã€ã¾ã•ã«ï¼ˆä»¥å‰è°è«–ã—ãŸï¼‰åå‰ä»˜ãクエリã®å®£è¨€ã§ã™ã€‚ ã“ã®åå‰ä»˜ãクエリをクラスã®ãƒžãƒƒãƒ”ングã‹ã‚‰å‚ç…§ã§ãã¾ã™ã€‚"
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr "ã“ã‚Œã¯ã‚¹ãƒˆã‚¢ãƒ‰ãƒ—ãƒã‚·ãƒ¼ã‚¸ãƒ£ã§ã•ãˆã‚‚動作ã—ã¾ã™ã€‚"
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr "次ã®ã‚ˆã†ã«ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ãŸã‚ã®ã‚¯ã‚¨ãƒªã•ãˆå®šç¾©ã—ã¦ã‚ˆã„ã§ã™ã€‚"
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr "次ã®ã‚ˆã†ã«ã€çµåˆãƒ•ã‚§ãƒƒãƒã«ã‚ˆã‚Šã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ エンティティãƒãƒ¼ãƒ€ãƒ¼ã‚’定義ã§ãã¾ã™ã€‚"
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,12 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1426 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr "オブジェクトを扱ã†"
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr "Hibernate ã¯å®Œå…¨ãªã‚ªãƒ–ジェクト/リレーショナルマッピングソリューションã§ã‚り〠データベース管ç†ã‚·ã‚¹ãƒ†ãƒ ã®è©³ç´°ã‚’開発者ã‹ã‚‰éš 蔽ã™ã‚‹ã ã‘ã§ãªã〠オブジェクト㮠<emphasis>状態管ç†</emphasis> ã‚‚è¡Œã„ã¾ã™ã€‚ ã“ã‚Œã¯ã€JDBC/SQL永続層ã¨åŒã˜ã‚ˆã†ãªSQL <literal>æ–‡</literal> ã®ç®¡ç†ã¨ã¯ç•°ãªã‚Šã€ Javaアプリケーションã«ãŠã‘る永続化ã«å¯¾ã™ã‚‹ã€ã¨ã¦ã‚‚自然ãªã‚ªãƒ–ジェクト指å‘ã®è€ƒãˆæ–¹ã‚’æä¾›ã—ã¾ã™ã€‚"
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr "言ã„ã‹ãˆã‚Œã°ã€Hibernateを用ã„るアプリケーション開発者ã¯ã€ã‚ªãƒ–ジェクト㮠<emphasis>状態</emphasis> ã«ã¤ã„ã¦ã¯ 常ã«æ„è˜ã™ã¹ãã§ã‚ã‚Šã€SQLæ–‡ã®å®Ÿè¡Œã«ã¤ã„ã¦ã¯å¿…ãšã—ã‚‚ãã†ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ã“ã®éƒ¨åˆ†ã¯ã€é€šå¸¸ã€HibernateãŒå‡¦ç†ã—ã€ã‚·ã‚¹ãƒ†ãƒ ã®ãƒ‘フォーマンスをãƒãƒ¥ãƒ¼ãƒ‹ãƒ³ã‚°ã™ã‚‹ã¨ãã«ã ã‘〠å•é¡Œã«ãªã£ã¦ãã¾ã™ã€‚"
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr "Hibernateã«ãŠã‘るオブジェクトã®çŠ¶æ…‹"
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr "Hibernateã¯æ¬¡ã®ã‚ˆã†ãªã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã‚’定義ã—ã€ã‚µãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr "<emphasis> 一時的(Transient) </emphasis> - <literal>new</literal> 演算åを使ã£ã¦ インスタンス化ã•ã‚ŒãŸã ã‘ã§ã€ Hibernateã® <literal>Session</literal> ã«é–¢é€£ä»˜ã‘られã¦ã„ãªã„オブジェクトã¯ã€ 一時的(transient)ã§ã™ã€‚ ãã‚Œã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«æ°¸ç¶šçš„ãªè¡¨ç¾ã‚’æŒãŸãšã€è˜åˆ¥åã¨ãªã‚‹å€¤ã¯å‰²ã‚Šå½“ã¦ã‚‰ã‚Œã¦ã„ã¾ã›ã‚“。 一時的ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ã‚¢ãƒ—リケーションãŒãã®å‚照をã©ã“ã«ã‚‚ä¿æŒã—ãªã„å ´åˆã«ã€ ガベージコレクタã«ã‚ˆã£ã¦ç ´æ£„ã•ã‚Œã¾ã™ã€‚ オブジェクトを永続的(persistent)ãªçŠ¶æ…‹ã«ã™ã‚‹ãŸã‚ã«ã¯ã€Hibernateã® <literal>Session</literal> を使ã„ã¾ã—ょã†ã€‚ （ã“ã®çŠ¶æ…‹é·ç§»ã«å¿…è¦ã¨ãªã‚‹SQLæ–‡ã®ç™ºè¡Œã¯ã€Hibernateã«ä»»ã›ã¾ã—ょã†ã€‚）"
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr "<emphasis>永続的(Persistent)</emphasis> - 永続的ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã« 永続的ãªè¡¨ç¾ã‚’æŒã¡ã€è˜åˆ¥åã¨ãªã‚‹å€¤ã‚’æŒã£ã¦ã„ã¾ã™ã€‚ ãã‚Œã¯ã€ã‚»ãƒ¼ãƒ–ã•ã‚ŒãŸã‚Šã€ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã‚Šã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“ãŒã€ 定義上ã¯ã€ <literal>Session</literal> ã®ã‚¹ã‚³ãƒ¼ãƒ—ã®ä¸ã«å˜åœ¨ã—ã¦ã„ã¾ã™ã€‚ Hibernateã¯ã€ä½œæ¥å˜ä½ï¼ˆUnit of work）ãŒå®Œäº†ã—ãŸã¨ãã«ã€ 永続状態ã®ã‚ªãƒ–ジェクトã«åŠ ãˆã‚‰ã‚ŒãŸå¤‰æ›´ã‚’検出ã—〠オブジェクトã®çŠ¶æ…‹ã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’åŒæœŸã—ã¾ã™ã€‚ オブジェクトを一時的(transient)ã«ã™ã‚‹ã¨ãã¯ã€é–‹ç™ºè€…ã¯ã€æ‰‹ä½œæ¥ã§ <literal>UPDATE</literal> 文や <literal>DELETE</literal> 文を実行ã—ã¾ã›ã‚“。"
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr "<emphasis>分離(Detached)</emphasis> - 分離ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¨ã¯ã€æ°¸ç¶šåŒ–ã•ã‚Œã¦ã„ã‚‹ãŒã€ ãã‚Œã¨é–¢é€£ä»˜ã„ã¦ã„㟠<literal>Session</literal> ãŒã‚¯ãƒãƒ¼ã‚ºã•ã‚Œã¦ã„るオブジェクトã®ã“ã¨ã§ã™ã€‚ ãã®ã‚ªãƒ–ジェクトã¸ã®å‚ç…§ã¯ã€ä¾ç„¶ã¨ã—ã¦æœ‰åŠ¹ã§ã™ã€‚ ãã—ã¦ã€ã‚‚ã¡ã‚ã‚“ã€åˆ†é›¢ã•ã‚ŒãŸçŠ¶æ…‹ã«ã‚るオブジェクトã¯ã€ä¿®æ£ã™ã‚‹ã“ã¨ã•ãˆã§ãã¾ã™ã€‚ 分離ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ã‚‚ã†ä¸€åº¦æ°¸ç¶šåŒ–ã—ãŸã„（ãã—ã¦ã€ã™ã¹ã¦ã®å¤‰æ›´ã‚’永続化ã—ãŸã„）ã¨ãã«ã€ æ–°ã—ã„ <literal>Session</literal> ã«å†è¿½åŠ ã§ãã¾ã™ã€‚ ã“ã®æ©Ÿèƒ½ã¯ã€ãƒ¦ãƒ¼ã‚¶ãŒè€ƒãˆã‚‹æ™‚é–“ã‚’å¿…è¦ã¨ã™ã‚‹ã‚ˆã†ãªã€é•·æœŸé–“ã«åŠã¶ä½œæ¥å˜ä½ã«å¯¾ã™ã‚‹ プãƒã‚°ãƒ©ãƒŸãƒ³ã‚°ãƒ¢ãƒ‡ãƒ«ã‚’å¯èƒ½ã«ã—ã¾ã™ã€‚ 我々ã¯ã€ã“れを <emphasis>アプリケーションã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆapplication transactions）</emphasis> ã¨å‘¼ã‚“ã§ã„ã¾ã™ã€‚ ã™ãªã‚ã¡ã€ãƒ¦ãƒ¼!
ザã‹ã‚‰è¦‹ãŸä½œæ¥å˜ä½ã ã¨ã„ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr "ã“ã‚Œã‹ã‚‰ã€çŠ¶æ…‹ã¨çŠ¶æ…‹é·ç§»ï¼ˆãã—ã¦ã€é·ç§»ã®ãã£ã‹ã‘ã¨ãªã‚‹Hibernateã®ãƒ¡ã‚½ãƒƒãƒ‰ï¼‰ã«ã¤ã„㦠ã€è©³ç´°ã«è¿°ã¹ã¾ã™ã€‚"
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr "オブジェクトを永続状態ã«ã™ã‚‹"
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr "æ–°ã—ãインスタンス化ã•ã‚ŒãŸæ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ Hibernateã§ã¯ <emphasis>一時的(transient)</emphasis> ã¨è¦‹ãªã•ã‚Œã¾ã™ã€‚ 以下ã®ã‚ˆã†ã«ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ã¨é–¢é€£ã¥ã‘ã‚‹ã“ã¨ã§ã€ä¸€æ™‚çš„ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’ <emphasis>永続状態(persistent)</emphasis> ã«ã§ãã¾ã™ã€‚"
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();
+\n"
+ "fritz.setColor(Color.GINGER);
+\n"
+ "fritz.setSex('M');
+\n"
+ "fritz.setName(\"Fritz\");
+\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr "<literal>Cat</literal> クラスã®è˜åˆ¥åãŒè‡ªå‹•ç”Ÿæˆã•ã‚Œã‚‹ã®ã§ã‚ã‚Œã°ã€ <literal>save()</literal> ãŒå‘¼ã°ã‚Œã‚‹ã¨ãã«ã€ è˜åˆ¥åãŒç”Ÿæˆã•ã‚Œã€ <literal>cat</literal> インスタンスã«å‰²ã‚Šå½“ã¦ã‚‰ã‚Œã¾ã™ã€‚ <literal>Cat</literal> ã®è˜åˆ¥åãŒä»–ã‹ã‚‰å‰²ã‚Šå½“ã¦ã‚‰ã‚Œã‚‹ï¼ˆ <literal>assigned</literal> è˜åˆ¥åã‚’æŒã¤ï¼‰ã‹ã€è¤‡åˆã‚ーã§ã‚ã‚‹ãªã‚‰ã€ <literal>save()</literal> を呼ã³å‡ºã™å‰ã«ã€è˜åˆ¥åを割り当ã¦ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <literal>save()</literal> ã®ä»£ã‚ã‚Šã«ã€EJB3 ã®åˆæœŸãƒ‰ãƒ©ãƒ•ãƒˆã§å®šç¾©ã•ã‚ŒãŸ <literal>persist()</literal> を使ã†ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr "代ã‚ã‚Šã«ã€è˜åˆ¥åを引数ã«ã¨ã‚‹ <literal>save()</literal> メソッドを使ã£ã¦ã€ è˜åˆ¥åを割り当ã¦ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();
+\n"
+ "pk.setColor(Color.TABBY);
+\n"
+ "pk.setSex('F');
+\n"
+ "pk.setName(\"PK\");
+\n"
+ "pk.setKittens( new HashSet() );
+\n"
+ "pk.addKitten(fritz);
+\n"
+ "sess.save( pk, new Long(1234) );]]>"
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr "永続化ã™ã‚‹ã‚ªãƒ–ジェクトãŒé–¢é€£ã‚ªãƒ–ジェクトをæŒã£ã¦ã„ã‚‹å ´åˆ ï¼ˆä¾‹ãˆã°ã€å‰ã®ä¾‹ã«ãŠã‘ã‚‹ <literal>kittens</literal> コレクションã®ã‚ˆã†ã«ï¼‰ã€ 外部ã‚ーカラムã«ã€ <literal>NOT NULL</literal> 制約をã¤ã‘ãªã„é™ã‚Šã¯ã€ ã“れらã®ä¸€é€£ã®ã‚ªãƒ–ジェクトをã©ã‚“ãªé †ç•ªã§æ°¸ç¶šåŒ–ã—ã¦ã‚‚ã‹ã¾ã„ã¾ã›ã‚“。 外部ã‚ー制約をé•åã™ã‚‹æã‚Œã¯ã‚ã‚Šã¾ã›ã‚“。 ã—ã‹ã—〠<literal>NOT NULL</literal> 制約ãŒã‚ã‚‹å ´åˆã€é–“é•ã£ãŸé †ç•ªã§ã‚ªãƒ–ジェクトを <literal>save()</literal> ã—ã¦ã—ã¾ã†ã¨ã€ 制約ã«é•åã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr "関連ã™ã‚‹ã‚ªãƒ–ジェクトを自動的ã«ä¿å˜ã™ã‚‹ã€ Hibernateã® <emphasis>é·ç§»çš„ãªæ°¸ç¶šåŒ–(transitive persistence)</emphasis> 機能を 使ã†ã¤ã‚‚ã‚Šãªã‚‰ã°ã€ãã®ã‚ˆã†ãªè©³ç´°ã‚’æ°—ã«ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 ãã—ã¦ã€ <literal>NOT NULL</literal> 制約ã®é•åã™ã‚‰èµ·ã“ã‚Šã¾ã›ã‚“。 HibernateãŒã™ã¹ã¦é¢å€’ã‚’ã¿ã¦ãã‚Œã¾ã™ã€‚é·ç§»çš„ãªæ°¸ç¶šåŒ–ã¯ã€ã“ã®ç« ã®å¾ŒåŠã«æ›¸ã‹ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr "オブジェクトã®ãƒãƒ¼ãƒ‰"
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr "永続化ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®è˜åˆ¥åãŒã‚らã‹ã˜ã‚分ã‹ã£ã¦ã„ã‚‹ãªã‚‰ã€ <literal>Session</literal> ã® <literal>load()</literal> メソッドを使ã£ã¦ã€å¾©å…ƒã§ãã¾ã™ã€‚ <literal>load()</literal> ã¯ã€Class オブジェクトを引数ã«ã¨ã‚Šã€ ãã®ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’æ–°ãŸã«ç”Ÿæˆã—ã€çŠ¶æ…‹ã‚’ãƒãƒ¼ãƒ‰ã—ã¾ã™ã€‚ ãã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®çŠ¶æ…‹ã¯ã€æ°¸ç¶š(persistent)状態ã§ã™ã€‚"
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+ "<![CDATA[// you need to wrap primitive identifiers
+\n"
+ "long id = 1234;
+\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr "ã‚ã‚‹ã„ã¯ã€ä»¥ä¸‹ã®ã‚ˆã†ã«ã€æ—¢å˜ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«çŠ¶æ…‹ã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();
+\n"
+ "// load pk's state into cat
+\n"
+ "sess.load( cat, new Long(pkId) );
+\n"
+ "Set kittens = cat.getKittens();]]>"
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr "DBã«è©²å½“ã™ã‚‹è¡ŒãŒç„¡ã„å ´åˆã€ <literal>load()</literal> ã¯å›žå¾©ä¸å¯èƒ½ãªä¾‹å¤–ã‚’ 投ã’ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¾ã—ょã†ã€‚ ãã®ã‚¯ãƒ©ã‚¹ãŒãƒ—ãƒã‚シを使ã£ã¦ãƒžãƒƒãƒ”ングã•ã‚Œã¦ã„ã‚‹å ´åˆã€ <literal>load()</literal> ã¯åˆæœŸåŒ–ã•ã‚Œã¦ã„ãªã„プãƒã‚ã‚·ã‚’è¿”ã—ã€ãƒ—ãƒã‚ã‚·ã®ãƒ¡ã‚½ãƒƒãƒ‰ãŒå‘¼ã°ã‚Œã‚‹ã¾ã§å®Ÿéš›ã«ã¯ データベースã«ã‚¢ã‚¯ã‚»ã‚¹ã—ã¾ã›ã‚“。 ã‚‚ã—ã€å®Ÿéš›ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰ãƒãƒ¼ãƒ‰ã›ãšã«ã€ã‚ªãƒ–ジェクトã«å¯¾ã™ã‚‹é–¢é€£ã‚’作りãŸã„å ´åˆã€ ã“ã®æŒ¯ã‚‹èˆžã„ã¯ã¨ã¦ã‚‚役立ã¡ã¾ã™ã€‚ <literal>batch-size</literal> ãŒã‚¯ãƒ©ã‚¹ãƒžãƒƒãƒ”ングã«å®šç¾©ã•ã‚Œã¦ã„ã‚‹ãªã‚‰ã°ã€ 複数ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’一括ã§ãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ãŒå¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr "該当ã™ã‚‹è¡ŒãŒå˜åœ¨ã™ã‚‹ã“ã¨ã‚’確信ã§ããªã„å ´åˆã¯ã€ <literal>get()</literal> メソッドを使ã†ã¹ãã§ã™ã€‚ ãã‚Œã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã™ãã«ã‚¢ã‚¯ã‚»ã‚¹ã—ã€è©²å½“ã™ã‚‹è¡ŒãŒç„¡ã„å ´åˆã¯nullã‚’è¿”ã—ã¾ã™ã€‚"
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);
+\n"
+ "if (cat==null) {
+\n"
+ " cat = new Cat();
+\n"
+ " sess.save(cat, id);
+\n"
+ "}
+\n"
+ "return cat;]]>"
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr "<literal>LockMode</literal> を使ãˆã°ã€ <literal>SELECT ... FOR UPDATE</literal>ã¨ã„ã†SQLã‚’ 使ã£ã¦ã‚ªãƒ–ジェクトをãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ 詳細ãªæƒ…å ±ã¯ã€APIドã‚ュメントをå‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr "関連ã«å¯¾ã™ã‚‹ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰æ–¹æ³•ã¨ã—㦠<literal>lock</literal> ã‚„ <literal>all</literal> ã‚’ 指定ã—ãªã„é™ã‚Šã€é–¢é€£ã™ã‚‹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚„å«ã¾ã‚Œã‚‹ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ <literal>FOR UPDATE</literal> ã§å¾©å…ƒ <emphasis>ã•ã‚Œãªã„</emphasis> ã“ã¨ã«æ³¨æ„ã—ã¾ã—ょã†ã€‚"
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr "<literal>refresh()</literal> メソッドを使ã†ã“ã¨ã§ã€ã©ã‚“ãªã¨ãã§ã‚‚ã€ã‚ªãƒ–ジェクトやãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ リãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ データベースã®ãƒˆãƒªã‚¬ãŒãƒ†ãƒ¼ãƒ–ルを更新ã—ãŸéš›ã«ã€ ãã®ãƒ†ãƒ¼ãƒ–ルã«å¯¾å¿œã™ã‚‹ã‚ªãƒ–ジェクトã®ãƒ—ãƒãƒ‘ティをåŒæœŸã™ã‚‹å ´åˆã€ã“ã®ãƒ¡ã‚½ãƒƒãƒ‰ãŒå½¹ã«ç«‹ã¡ã¾ã™ã€‚"
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+ "<![CDATA[sess.save(cat);
+\n"
+ "sess.flush(); //force the SQL INSERT
+\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr "大切ãªå•é¡Œã¯ã€ã„ã¤ã‚‚次ã®ç‚¹ã«é–¢ã™ã‚‹ã‚‚ã®ã§ã™ã€‚ãã‚Œã¯ã€HibernateãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰ã€ ã©ã®ãらã„ã®é‡ã‚’復元ã™ã‚‹ã®ã‹ã¨ã€ã©ã®ãらã„ã®æ•°ã®SQLã® <literal>SELECT</literal> æ–‡ãŒä½¿ã‚れるã®ã‹ã§ã™ã€‚ ã“ã‚Œã¯ã€ <emphasis>フェッãƒã®æˆ¦ç•¥</emphasis> ã«ã‚ˆã‚Šã¾ã™ã€‚ã“ã‚Œã«ã¤ã„ã¦ã¯ã€<xref linkend=\"performance-fetching\"/> ã§èª¬æ˜Žã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr "<title>クエリ</title>"
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr "探ã—ãŸã„オブジェクトã®è˜åˆ¥åãŒåˆ†ã‹ã‚‰ãªã„å ´åˆã¯ã€ã‚¯ã‚¨ãƒªãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚ Hibernateã¯ä½¿ã„ã‚„ã™ãã¦å¼·åŠ›ãªã‚ªãƒ–ジェクト指å‘ã®ã‚¯ã‚¨ãƒªè¨€èªž (HQL)をサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ プãƒã‚°ãƒ©ãƒ ã«ã‚ˆã£ã¦ã‚¯ã‚¨ãƒªãŒä½œæˆã§ãるよã†ã«ã€Hibernateã¯æ´—ç·´ã•ã‚ŒãŸCriteriaã¨Exampleクエリ機能(QBCã¨QBE）を サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ResultSetをオブジェクトã«å¤‰æ›ã™ã‚‹Hibernateã®ã‚ªãƒ—ション機能を使ã†ã“ã¨ã§ã€ データベースã®ãƒã‚¤ãƒ†ã‚£ãƒ–ãªSQLã§ã‚¯ã‚¨ãƒªã‚’表ç¾ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:219
+msgid "Querying"
+msgstr "クエリã®å®Ÿè¡Œ"
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr "HQLã‚„ãƒã‚¤ãƒ†ã‚£ãƒ–ãªSQLクエリã¯ã€ <literal>org.hibernate.Query</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¨ã—ã¦è¡¨ç¾ã•ã‚Œã¾ã™ã€‚ ã“ã®ã‚¤ãƒ³ã‚¿ãƒ•ã‚§ãƒ¼ã‚¹ã¯ã€ãƒ‘ラメータãƒã‚¤ãƒ³ãƒ‡ã‚£ãƒ³ã‚°ã‚„ResultSetã®ãƒãƒ³ãƒ‰ãƒªãƒ³ã‚°ã‚„ クエリã®å®Ÿè¡Œã‚’è¡Œã†ãƒ¡ã‚½ãƒƒãƒ‰ã‚’用æ„ã—ã¦ã„ã¾ã™ã€‚ 通常〠<literal>Query</literal> ã¯ã€ä»¥ä¸‹ã«ç¤ºã™ã‚ˆã†ã«ã€ ãã®æ™‚点㮠<literal>Session</literal> を使ã£ã¦å–å¾—ã—ã¾ã™ã€‚"
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+ "<![CDATA[List cats = session.createQuery(
+\n"
+ " \"from Cat as cat where cat.birthdate < ?\")
+\n"
+ " .setDate(0, date)
+\n"
+ " .list();
+\n"
+ "
+\n"
+ "List mothers = session.createQuery(
+\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")
+\n"
+ " .setString(0, name)
+\n"
+ " .list();
+\n"
+ "
+\n"
+ "List kittens = session.createQuery(
+\n"
+ " \"from Cat as cat where cat.mother = ?\")
+\n"
+ " .setEntity(0, pk)
+\n"
+ " .list();
+\n"
+ "
+\n"
+ "Cat mother = (Cat) session.createQuery(
+\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")
+\n"
+ " .setEntity(0, izi)
+\n"
+ " .uniqueResult();]]
+\n"
+ "
+\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(
+\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");
+\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());
+\n"
+ "
+\n"
+ " ]]>"
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr "クエリã¯ã€æ™®é€šã€ <literal>list()</literal> を呼ã³å‡ºã™ã“ã¨ã«ã‚ˆã£ã¦å®Ÿè¡Œã•ã‚Œã¾ã™ã€‚ クエリã®çµæžœã¯ã€ãƒ¡ãƒ¢ãƒªä¸Šã«ã‚るコレクションã«ã™ã¹ã¦ãƒãƒ¼ãƒ‰ã•ã‚Œã¾ã™ã€‚ クエリã«ã‚ˆã£ã¦å¾©å…ƒã•ã‚ŒãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€æ°¸ç¶šçŠ¶æ…‹ã§ã™ã€‚ ã‚‚ã—ã€ã‚¯ã‚¨ãƒªãŒãŸã£ãŸ1個ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’è¿”ã™ã¨åˆ†ã‹ã£ã¦ã„ã‚‹ãªã‚‰ã€ <literal>uniqueResult()</literal> メソッドãŒæ‰‹ã£å–ã‚Šæ—©ã„方法ã§ã™ã€‚ å³æ™‚フェッãƒã‚’利用ã—ãŸã‚¯ã‚¨ãƒªã®å ´åˆã€ãµã¤ã†ã€å¾—られãŸã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã¯ã€ ルートã®ã‚ªãƒ–ジェクトãŒé‡è¤‡ã—ã¦å«ã¾ã‚Œã¦ã„ã¾ã™ （ã—ã‹ã—ã€ãƒ«ãƒ¼ãƒˆãŒæŒã¤ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯åˆæœŸåŒ–(ãƒãƒ¼ãƒ‰ï¼‰ã•ã‚Œã¦ã„ã¾ã™ï¼‰ã€‚ ã“ã®é‡è¤‡ã¯ <literal>Set</literal> を使ã£ã¦å–り除ãã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr "çµæžœã‚’イテレートã™ã‚‹"
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr "時々〠<literal>iterate()</literal> メソッドを使ã£ã¦ã‚¯ã‚¨ãƒªã‚’実行ã™ã‚‹ã“ã¨ã§ã€ より良ã„パフォーマンスを得るã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã‚Œã¯ã€é€šå¸¸ã€ã‚¯ã‚¨ãƒªã«ã‚ˆã£ã¦å¾—られãŸå®Ÿéš›ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã€ ã™ã§ã«ã‚»ãƒƒã‚·ãƒ§ãƒ³ã¾ãŸã¯äºŒæ¬¡ã‚ャッシュã«å˜åœ¨ã™ã‚‹ã“ã¨ãŒæœŸå¾…ã§ãã‚‹å ´åˆã ã‘ã§ã™ã€‚ ãれらãŒã€ã¾ã ã‚ャッシュã•ã‚Œã¦ã„ãªã„ãªã‚‰ã€ <literal>iterate()</literal> ã¯ã€ <literal>list()</literal> よりもé…ãã€ç°¡å˜ãªã‚¯ã‚¨ãƒªã«å¯¾ã—ã¦ã‚‚多ãã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¢ã‚¯ã‚»ã‚¹ã‚’ å¿…è¦ã¨ã—ã¾ã™ã€‚ãã®ã‚¢ã‚¯ã‚»ã‚¹ã¨ã¯ã€è˜åˆ¥åã ã‘ã‚’å–å¾—ã™ã‚‹ãŸã‚ã®æœ€åˆã®select１回ã¨ã€ 実際ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’åˆæœŸåŒ–ã™ã‚‹ãŸã‚ã«å¾Œã‹ã‚‰è¡Œã†n回ã®selectã®ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+ "<![CDATA[// fetch ids
+\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();
+\n"
+ "while ( iter.hasNext() ) {
+\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object
+\n"
+ " // something we couldnt express in the query
+\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {
+\n"
+ " // delete the current instance
+\n"
+ " iter.remove();
+\n"
+ " // dont need to process the rest
+\n"
+ " break;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr "オブジェクトã®çµ„（tuple）を返ã™ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr "Hibernateã®ã‚¯ã‚¨ãƒªã§ã¯ã€æ™‚々ã€ã‚ªãƒ–ジェクトã®çµ„ã‚’è¿”ã™ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ ãã®å ´åˆã¯ã€å„タプルã¯é…列ã¨ã—ã¦è¿”ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(
+\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")
+\n"
+ " .list()
+\n"
+ " .iterator();
+\n"
+ "
+\n"
+ "while ( kittensAndMothers.hasNext() ) {
+\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();
+\n"
+ " Cat kitten = (Cat) tuple[0];
+\n"
+ " Cat mother = (Cat) tuple[1];
+\n"
+ " ....
+\n"
+ "}]]>"
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr "スカラーã®çµæžœ"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr "クエリã§ã¯ã€ <literal>select</literal> 節ã§ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティを指定ã§ãã¾ã™ã€‚ SQLã®é›†åˆé–¢æ•°ã‚’呼ã¶ã“ã¨ã‚‚ã§ãã¾ã™ã€‚プãƒãƒ‘ティや集åˆé–¢æ•°ã¯ã€ （永続状態ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã§ã¯ãªã）「スカラー値ã€ã§ã‚ã‚‹ã¨è¦‹ãªã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+ "<![CDATA[Iterator results = sess.createQuery(
+\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +
+\n"
+ " \"group by cat.color\")
+\n"
+ " .list()
+\n"
+ " .iterator();
+\n"
+ "
+\n"
+ "while ( results.hasNext() ) {
+\n"
+ " Object[] row = (Object[]) results.next();
+\n"
+ " Color type = (Color) row[0];
+\n"
+ " Date oldest = (Date) row[1];
+\n"
+ " Integer count = (Integer) row[2];
+\n"
+ " .....
+\n"
+ "}]]>"
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr "パラメータã®ãƒã‚¤ãƒ³ãƒ‰"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr "<literal>Query</literal> ã¯ã€åå‰ä»˜ãã®ãƒ‘ラメータやJDBCスタイル㮠<literal>?</literal> パラメータã«å€¤ã‚’ãƒã‚¤ãƒ³ãƒ‰ã™ã‚‹ãŸã‚ã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’æŒã£ã¦ã„ã¾ã™ã€‚ <emphasis>JDBCã¨ã¯é•ã„ã€Hibernateã¯ãƒ‘ラメータã«ã‚¼ãƒã‹ã‚‰ç•ªå·ã‚’振ã£ã¦ã„ãã¾ã™ã€‚</emphasis> åå‰ä»˜ãã®ãƒ‘ラメータã¨ã¯ã€ã‚¯ã‚¨ãƒªæ–‡å—列ã®ãªã‹ã«ã‚ã‚‹ <literal>:name</literal> å½¢å¼ã®è˜åˆ¥åã§ã™ã€‚ åå‰ä»˜ãパラメータã®åˆ©ç‚¹ã¯æ¬¡ã®é€šã‚Šã§ã™ã€‚"
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr "åå‰ä»˜ãパラメータã¯ã€ã‚¯ã‚¨ãƒªæ–‡å—列ã«ç™»å ´ã™ã‚‹é †ç•ªã¨ç„¡é–¢ä¿‚ã§ã™"
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr "åŒã˜ã‚¯ã‚¨ãƒªå†…ã«è¤‡æ•°å›žç™»å ´ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™"
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr "自分自身を説明ã—ã¾ã™"
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+ "<![CDATA[//named parameter (preferred)
+\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");
+\n"
+ "q.setString(\"name\", \"Fritz\");
+\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+ "<![CDATA[//positional parameter
+\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");
+\n"
+ "q.setString(0, \"Izi\");
+\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+ "<![CDATA[//named parameter list
+\n"
+ "List names = new ArrayList();
+\n"
+ "names.add(\"Izi\");
+\n"
+ "names.add(\"Fritz\");
+\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");
+\n"
+ "q.setParameterList(\"namesList\", names);
+\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr "ページ分ã‘"
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr "ResultSetã«åˆ¶é™ï¼ˆå¾©å…ƒã—ãŸã„最大行数や復元ã—ãŸã„最åˆã®è¡Œï¼‰ã‚’åŠ ãˆã‚‹å¿…è¦ãŒã‚ã‚Œã°ã€ 以下ã®ã‚ˆã†ã«ã€ <literal>Query</literal> インターフェイスã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’使ã„ã¾ã™ã€‚"
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");
+\n"
+ "q.setFirstResult(20);
+\n"
+ "q.setMaxResults(10);
+\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr "制é™ä»˜ãã®ã‚¯ã‚¨ãƒªã‚’DBMSã®ãƒã‚¤ãƒ†ã‚£ãƒ–ãªSQLã«å¤‰æ›ã™ã‚‹æ–¹æ³•ã‚’ã€Hibernateã¯çŸ¥ã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr "スクãƒãƒ¼ãƒ«å¯èƒ½ãªã‚¤ãƒ†ãƒ¬ãƒ¼ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr "JDBCドライãƒãŒã‚¹ã‚¯ãƒãƒ¼ãƒ«å¯èƒ½ãª <literal>ResultSet</literal> をサãƒãƒ¼ãƒˆã—ã¦ã„ã‚Œã°ã€ <literal>Query</literal> インターフェイスを使ã£ã¦ã€ <literal>ScrollableResults</literal> オブジェクトを å–å¾—ã§ãã¾ã™ã€‚ãれを使ã†ã¨ã€ã‚¯ã‚¨ãƒªã®çµæžœã«å¯¾ã—ã¦æŸ”軟ã«ãƒŠãƒ“ゲーションã§ãã¾ã™ã€‚"
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +
+\n"
+ " \"order by cat.name\");
+\n"
+ "ScrollableResults cats = q.scroll();
+\n"
+ "if ( cats.first() ) {
+\n"
+ "
+\n"
+ " // find the first name on each page of an alphabetical list of cats by name
+\n"
+ " firstNamesOfPages = new ArrayList();
+\n"
+ " do {
+\n"
+ " String name = cats.getString(0);
+\n"
+ " firstNamesOfPages.add(name);
+\n"
+ " }
+\n"
+ " while ( cats.scroll(PAGE_SIZE) );
+\n"
+ "
+\n"
+ " // Now get the first page of cats
+\n"
+ " pageOfCats = new ArrayList();
+\n"
+ " cats.beforeFirst();
+\n"
+ " int i=0;
+\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );
+\n"
+ "
+\n"
+ "}
+\n"
+ "cats.close()]]>"
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr "ã“ã®æ©Ÿèƒ½ã«ã¯ã‚ªãƒ¼ãƒ—ン状態ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãŒå¿…è¦ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã‚‚ã—ã€ã‚ªãƒ•ãƒ©ã‚¤ãƒ³ã®ãƒšãƒ¼ã‚¸åˆ†ã‘機能ãŒå¿…è¦ã§ã‚ã‚Œã°ã€ <literal>setMaxResult()</literal> / <literal>setFirstResult()</literal> を使ã„ã¾ã—ょã†ã€‚"
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr "åå‰ä»˜ãクエリã®å¤–出ã—"
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr "マッピングドã‚ュメントã«åå‰ä»˜ãã®ã‚¯ã‚¨ãƒªã‚’定義ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ （マークアップã¨è§£é‡ˆã•ã‚Œã‚‹æ–‡å—ãŒã‚¯ã‚¨ãƒªã«å«ã¾ã‚Œã‚‹ãªã‚‰ã€ <literal>CDATA</literal> セクションを 使ã†ã“ã¨ã‚’忘れãªã„よã†ã«ã—ã¾ã—ょã†ã€‚）"
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[
+\n"
+ " from eg.DomesticCat as cat
+\n"
+ " where cat.name = ?
+\n"
+ " and cat.weight > ?
+\n"
+ "] ]></query>]]>"
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr "パラメータã®ãƒã‚¤ãƒ³ãƒ‡ã‚£ãƒ³ã‚°ã¨å®Ÿè¡Œã¯ã€ä»¥ä¸‹ã®ã‚ˆã†ãªãƒ—ãƒã‚°ãƒ©ãƒ ã§è¡Œã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");
+\n"
+ "q.setString(0, name);
+\n"
+ "q.setInt(1, minWeight);
+\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr "実際ã®ãƒ—ãƒã‚°ãƒ©ãƒ コードã¯ã€ä½¿ã‚れるクエリ言語ã«ä¾å˜ã—ã¦ã„ãªã„ã“ã¨ã«æ³¨æ„ã—ã¾ã—ょã†ã€‚ メタデータã«ã¯ã€ãƒã‚¤ãƒ†ã‚£ãƒ–SQLクエリを定義ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ã¾ãŸã€æ—¢å˜ã®ã‚¯ã‚¨ãƒªã‚’マッピングファイルã«ç§»ã™ã“ã¨ã§ã€ Hibernateã«ç§»è¡Œã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr "<literal><hibernate-mapping></literal> ã®ä¸ã®ã‚¯ã‚¨ãƒªå®šç¾©ã¯ã€ã‚¯ã‚¨ãƒªã«å¯¾ã™ã‚‹ ユニークãªåå‰ãŒå¿…è¦ãªã“ã¨ã«ã‚‚注æ„ã—ã¦ãã ã•ã„。ãã‚Œã«å¯¾ã—ã¦ã€ <literal><class></literal> ã®ä¸ã® クエリ定義ã¯ã€ã‚¯ãƒ©ã‚¹ã®å®Œå…¨é™å®šåãŒå‰ã«ä»˜ã‘られるã®ã§ã€è‡ªå‹•çš„ã«ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªåå‰ã«ãªã‚Šã¾ã™ã€‚ 例： <literal>eg.Cat.ByNameAndMaximumWeight</literal>"
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr "コレクションã®ãƒ•ã‚£ãƒ«ã‚¿ãƒªãƒ³ã‚°"
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr "コレクション <emphasis>フィルタ</emphasis> ã¯ã€æ°¸ç¶šåŒ–ã•ã‚Œã¦ã„るコレクションやé…列ã«é©ç”¨ã•ã‚Œã‚‹ 特殊ãªã‚¿ã‚¤ãƒ—ã®ã‚¯ã‚¨ãƒªã§ã™ã€‚ãã®ã‚¯ã‚¨ãƒªæ–‡å—列ã§ã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ãã®æ™‚点ã§ã®è¦ç´ ã‚’æ„味ã™ã‚‹ <literal>this</literal> を使ã„ã¾ã™ã€‚"
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr ""
+ "<![CDATA[Collection blackKittens = session.createFilter(
+\n"
+ " pk.getKittens(),
+\n"
+ " \"where this.color = ?\")
+\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )
+\n"
+ " .list()
+\n"
+ ");]]>"
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr "è¿”ã•ã‚Œã‚‹ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯Bagã¨ã¿ãªã•ã‚Œã¾ã™ã€‚ãã—ã¦ã€ãã‚Œã¯ã‚‚ã¨ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚³ãƒ”ーã«ãªã‚Šã¾ã™ã€‚ å…ƒã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ä¿®æ£ã•ã‚Œã¾ã›ã‚“（ã“ã‚Œã¯ã€\"filter\"ã¨ã„ã†åå‰ã®æ„味ã¨ã¯ç•°ãªã‚Šã¾ã™ãŒã€ 期待ã•ã‚Œã‚‹å‹•ãã¨ã¯ä¸€è‡´ã—ã¦ã„ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr "フィルタã«ã¯ <literal>from</literal> 節ãŒä¸è¦ã§ã‚ã‚‹ã“ã¨ã«æ°—ã¥ãã§ã—ょã†ï¼ˆå¿…è¦ãªã‚‰ã€æŒã¤ã“ã¨ã‚‚å¯èƒ½ã§ã™ãŒï¼‰ã€‚ フィルタã¯ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ 自体を返ã—ã¦æ§‹ã„ã¾ã›ã‚“。"
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(
+\n"
+ " pk.getKittens(),
+\n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")
+\n"
+ " .list();]]>"
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr "クエリをå«ã¾ãªã„フィルタも役ã«ç«‹ã¡ã¾ã™ã€‚ 例ãˆã°ã€éžå¸¸ã«å¤§ããªã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®éƒ¨åˆ†é›†åˆã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ãŸã‚ã«ä½¿ãˆã¾ã™ã€‚"
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Collection tenKittens = session.createFilter(
+\n"
+ " mother.getKittens(), \"\")
+\n"
+ " .setFirstResult(0).setMaxResults(10)
+\n"
+ " .list();]]>"
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr "クライテリアã®ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr "HQLã¯éžå¸¸ã«å¼·åŠ›ã§ã™ãŒã€ã‚¯ã‚¨ãƒªæ–‡å—列を作るよりもã€ã‚ªãƒ–ジェクト指å‘ã®APIを使ã£ã¦ å‹•çš„ã«ã‚¯ã‚¨ãƒªã‚’作る方を好む開発者もã„ã¾ã™ã€‚ ã“ã†ã„ã£ãŸå ´åˆã®ãŸã‚ã«ã€Hibernateã¯ç›´æ„Ÿçš„㪠<literal>Criteria</literal> クエリAPIã‚’æä¾›ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);
+\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );
+\n"
+ "crit.setMaxResults(10);
+\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr "<literal>Criteria</literal> 㨠<literal>Example</literal> APIã®è©³ç´°ã¯ã€ <xref linkend=\"querycriteria\"/> ã«è¿°ã¹ã‚‰ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr "ãƒã‚¤ãƒ†ã‚£ãƒ–SQLã®ã‚¯ã‚¨ãƒª"
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr "<literal>createSQLQuery()</literal> を使ã£ã¦ã€SQLã§ã‚¯ã‚¨ãƒªã‚’表ç¾ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ãã—ã¦ã€Hibernateã«ã€ResultSet ã‹ã‚‰ã‚ªãƒ–ジェクトã¸ã®ãƒžãƒƒãƒ”ングをã¾ã‹ã›ã¾ã™ã€‚ <literal>session.connection()</literal> を呼ã¹ã°ã©ã‚“ãªã¨ãã§ã‚‚ã€ç›´æŽ¥ã€JDBC <literal>Connection</literal> を使用ã§ãã‚‹ã“ã¨ã‚’覚ãˆã¦ãŠãã¾ã—ょã†ã€‚ ã‚‚ã—ã€Hibernate APIを使ã†ã®ã§ã‚ã‚Œã°ã€ä¸‹è¨˜ã®ã‚ˆã†ã«SQLã®åˆ¥åを括弧ã§ããらãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list();]]>"
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(
+\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +
+\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +
+\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list()]]>"
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr "SQLクエリã¯ã€Hibernateクエリã¨åŒã˜ã‚ˆã†ã«ã€åå‰ä»˜ãã®ãƒ‘ラメータã¨ä½ç½®ãƒ‘ラメータをæŒã¤ã“ã¨ãŒã§ãã¾ã™ã€‚ Hibernateã«ãŠã‘ã‚‹ãƒã‚¤ãƒ†ã‚£ãƒ–ãªSQLクエリã®è©³ç´°ã«ã¤ã„ã¦ã¯ã€ <xref linkend=\"querysql\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr "永続オブジェクトã®ä¿®æ£"
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr "<emphasis>処ç†ä¸ã®æ°¸ç¶šã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹</emphasis> （例： <literal>Session</literal> ã«ã‚ˆã£ã¦ã€ ãƒãƒ¼ãƒ‰ã€ã‚»ãƒ¼ãƒ–ã€ä½œæˆã€ã‚¯ã‚¨ãƒªã•ã‚ŒãŸã‚ªãƒ–ジェクト）ã¯ã€ã‚¢ãƒ—リケーションã«æ“作ã•ã‚Œã¾ã™ã€‚ ãã®éš›ã«å¤‰æ›´ã•ã‚ŒãŸæ°¸ç¶šçŠ¶æ…‹ã¯ã€ <literal>Session</literal> ㌠<emphasis>フラッシュ</emphasis> ã•ã‚Œã‚‹ã¨ãã«ã€æ°¸ç¶šåŒ–ã•ã‚Œã¾ã™ï¼ˆã“ã‚Œã¯ã€ã“ã®ç« ã®å¾ŒåŠã§è¿°ã¹ã¦ã„ã¾ã™ï¼‰ã€‚ 変更を永続化ã™ã‚‹ãŸã‚ã«ã€ç‰¹æ®Šãªãƒ¡ã‚½ãƒƒãƒ‰ï¼ˆ <literal>update()</literal> ã®ã‚ˆã†ãªã‚‚ã®ã€‚ã“ã‚Œã¯ã€åˆ¥ã®ç›®çš„ã§ä½¿ç”¨ã—ã¾ã™ï¼‰ã‚’ 呼ã¶å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 オブジェクトã®çŠ¶æ…‹ã‚’æ›´æ–°ã™ã‚‹ä¸€ç•ªç°¡å˜ãªæ–¹æ³•ã¯ã€ã‚ªãƒ–ジェクトを <literal>load()</literal> ã—〠<literal>Session</literal> をオープンã«ã—ã¦ã„ã‚‹é–“ã«ã€ç›´æŽ¥æ“作ã™ã‚‹ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );
+\n"
+ "cat.setName(\"PK\");
+\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted
+\n"
+ "]]>"
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr "（オブジェクトをãƒãƒ¼ãƒ‰ã™ã‚‹ãŸã‚ã®ï¼‰SQLã® <literal>SELECT</literal> ã¨ï¼ˆæ›´æ–°ã•ã‚ŒãŸçŠ¶æ…‹ã‚’永続化ã™ã‚‹ãŸã‚ã®ï¼‰ SQLã® <literal>UPDATE</literal> ãŒåŒã˜ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§å¿…è¦ã¨ãªã‚‹ã®ã§ã€ã“ã®ãƒ—ãƒã‚°ãƒ©ãƒŸãƒ³ã‚°ãƒ¢ãƒ‡ãƒ«ã¯ã€ 効率ãŒæ‚ªããªã‚‹å ´åˆãŒã‚ã‚Šã¾ã™ã€‚ ãã®ãŸã‚ã€Hibernateã¯åˆ¥ã®æ–¹æ³•ã‚’用æ„ã—ã¦ã„ã¾ã™ã€‚ãã‚Œã¯ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’分離ã™ã‚‹ï¼ˆdetached）方法ã§ã™ã€‚"
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr "Hibernateã¯ã€ <literal>UPDATE</literal> 文や <literal>DELETE</literal> 文を直接実行ã™ã‚‹APIを用æ„ã—ã¦ã„ã¾ã›ã‚“。 Hibernateã¯ã€ <emphasis>状態管ç†</emphasis> サービスã§ã‚ã‚Šã€ä½¿ã‚れるSQL <emphasis>æ–‡</emphasis> ã®ã“ã¨ã‚’開発者ãŒè€ƒãˆã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 JDBCã¯SQL文を実行ã™ã‚‹å®Œç’§ãªAPIã§ã‚り〠<literal>session.connection()</literal> を呼ã¶ã“ã¨ã§ ã„ã¤ã§ã‚‚ã€JDBC <literal>Connection</literal> を開発者ã¯å–å¾—ã§ãã¾ã™ã€‚ ã•ã‚‰ã«ã€å¤§é‡ã®ãƒ‡ãƒ¼ã‚¿æ“作ã®è€ƒãˆæ–¹ã¯ã€ã‚ªãƒ³ãƒ©ã‚¤ãƒ³ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å‡¦ç†å‘ãアプリケーション㮠オブジェクト/リレーショナルマッピングã¨è¡çªã—ã¾ã™ã€‚ ã—ã‹ã—ã€Hibernateã®ä»Šå¾Œã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã§ã¯ã€å¤§é‡ãƒ‡ãƒ¼ã‚¿ã‚’処ç†ã™ã‚‹ç‰¹åˆ¥ãªæ©Ÿèƒ½ã‚’æä¾›ã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ãƒãƒƒãƒæ“作ã«åˆ©ç”¨ã§ãã‚‹ã„ãã¤ã‹ã®å·¥å¤«ã«ã¤ã„ã¦ã¯ã€ <xref linkend=\"batch\"/> ã‚’å‚ç…§ã—ã¦ãã !
ã•ã„。"
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr "分離オブジェクトã®ä¿®æ£"
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr "多ãã®ã‚¢ãƒ—リケーションã§ã¯æ¬¡ã®ã“ã¨ãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚ ãã‚Œã¯ã€ã‚るトランザクションã§ã‚ªãƒ–ジェクトを復元ã—ã€æ“作ã™ã‚‹ãŸã‚ã«ãれをUI層ã«é€ã‚Šã€ ãã®å¾Œã«ã€æ–°ã—ã„トランザクションã§å¤‰æ›´ã‚’セーブã™ã‚‹ã¨ã„ã£ãŸã“ã¨ã§ã™ã€‚ 並行性ã®é«˜ã„環境ã§ã€ã“ã®ã‚¿ã‚¤ãƒ—ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’使ã†ã‚¢ãƒ—リケーションã§ã¯ã€ \"期間ã®é•·ã„\" 作æ¥å˜ä½ã®éš”離性をä¿è¨¼ã™ã‚‹ãŸã‚ã«ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒ‡ãƒ¼ã‚¿ãŒé€šå¸¸ä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr "Hibernateã¯ã€ <literal>Session.update()</literal> ã‚„ <literal>Session.merge()</literal> メソッドを 使ã£ã¦ã€åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’å†è¿½åŠ ã™ã‚‹ã“ã¨ã§ã€ã“ã®ãƒ¢ãƒ‡ãƒ«ã«å¯¾å¿œã—ã¾ã™ã€‚"
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr ""
+ "<![CDATA[// in the first session
+\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);
+\n"
+ "Cat potentialMate = new Cat();
+\n"
+ "firstSession.save(potentialMate);
+\n"
+ "
+\n"
+ "// in a higher layer of the application
+\n"
+ "cat.setMate(potentialMate);
+\n"
+ "
+\n"
+ "// later, in a new session
+\n"
+ "secondSession.update(cat); // update cat
+\n"
+ "secondSession.update(mate); // update mate]]>"
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr "è˜åˆ¥å<literal>catId</literal> ã‚’æŒã¤ <literal>Cat</literal> ãŒã€æ—¢ã« <literal>secondSession</literal> ã§ãƒãƒ¼ãƒ‰ã•ã‚Œã¦ã„ãŸå ´åˆã¯ã€å†è¿½åŠ ã—よã†ã¨ã—ãŸã¨ãã«ã€ä¾‹å¤–ãŒæŠ•ã’られã¾ã™ã€‚"
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr "åŒã˜è˜åˆ¥åã‚’æŒã¤æ°¸ç¶šã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’セッションãŒæ—¢ã«ä¿æŒã—ã¦ã„ãªã„ã“ã¨ã‚’ 確信ã§ãã‚‹ãªã‚‰ <literal>update()</literal> を使ã„ã¾ã—ょã†ã€‚ ãã—ã¦ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ã®çŠ¶æ…‹ã‚’考ãˆãšã«ã€ã©ã‚“ãªå ´åˆã§ã‚‚変更をマージã—ãŸã„å ´åˆã¯ã€ <literal>merge()</literal> を使ã„ã¾ã—ょã†ã€‚ ã™ãªã‚ã¡ã€åˆ†é›¢ã‚ªãƒ–ジェクトã®å†è¿½åŠ æ“作ãŒã€æœ€åˆã«å®Ÿè¡Œã•ã‚Œã‚‹ã“ã¨ã‚’確実ã«ã™ã‚‹ãŸã‚ã«ã€ 通常㯠<literal>update()</literal> ãŒæ–°ã—ã„セッションã®ãªã‹ã§æœ€åˆã«å‘¼ã°ã‚Œã‚‹ãƒ¡ã‚½ãƒƒãƒ‰ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr "分離インスタンスã‹ã‚‰åˆ°é”å¯èƒ½ãªã€åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’アプリケーションã¯å€‹åˆ¥ã« <literal>update()</literal> ã™ã¹ãã§ã™ã€‚ãã‚Œã¯ã€ãã®çŠ¶æ…‹ã‚’æ›´æ–°ã—ãŸã„å ´åˆã« <emphasis>é™ã‚Š</emphasis> ã¾ã™ã€‚ <emphasis>é·ç§»çš„ãªæ°¸ç¶šåŒ–</emphasis> を使ãˆã°ã€ã‚‚ã¡ã‚ん自動化ã§ãã¾ã™ã€‚ <xref linkend=\"objectstate-transitive\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr "メソッドã§ã‚‚ã¾ãŸã€æ–°ã—ã„セッションã«ã‚ªãƒ–ジェクトをå†é–¢é€£ä»˜ã‘ã§ãã¾ã™ã€‚ ã—ã‹ã—ã€åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ç„¡ä¿®æ£ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr ""
+ "<![CDATA[//just reassociate:
+\n"
+ "sess.lock(fritz, LockMode.NONE);
+\n"
+ "//do a version check, then reassociate:
+\n"
+ "sess.lock(izi, LockMode.READ);
+\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:
+\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr "<literal>lock()</literal> ã¯ã€ã•ã¾ã–ã¾ãª <literal>LockMode</literal> ã¨ã¨ã‚‚ã«ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ 詳細ã¯ã€APIドã‚ュメントã¨ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å‡¦ç†ã®ç« ã‚’å‚ç…§ã—ã¦ãã ã•ã„。 å†è¿½åŠ ã®ã¨ãã«ã ã‘〠<literal>lock()</literal> ãŒä½¿ã‚れるã‚ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr "期間ã®é•·ã„作æ¥å˜ä½ã®ã€ãã®ä»–ã®ãƒ¢ãƒ‡ãƒ«ã¯ã€<xref linked=\"transactions-optimistic\"/> ã§è¿°ã¹ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr "自動的ãªçŠ¶æ…‹æ¤œå‡º"
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr "Hibernateã®ãƒ¦ãƒ¼ã‚¶ã¯æ¬¡ã®2ã¤ã®ã‚±ãƒ¼ã‚¹ã®ã©ã¡ã‚‰ã«ã‚‚使ãˆã‚‹æ±Žç”¨çš„ãªãƒ¡ã‚½ãƒƒãƒ‰ã‚’è¦æ±‚ã—ã¦ã„ã¾ã—ãŸã€‚ ãã‚Œã¯ã€æ–°ã—ã„è˜åˆ¥åを生æˆã—ã¦ä¸€æ™‚çš„ãªã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’セーブã™ã‚‹ã“ã¨ã¨ã€ ãã®æ™‚点ã®è˜åˆ¥åã¨é–¢é€£ã¥ã„ã¦ã„る分離インスタンスを更新/å†è¿½åŠ ã™ã‚‹ã“ã¨ã®ã§ãるメソッドã§ã™ã€‚ <literal>saveOrUpdate()</literal> ã¯ã“ã®ã‚ˆã†ãªæ©Ÿèƒ½ã‚’実ç¾ã—ãŸãƒ¡ã‚½ãƒƒãƒ‰ã§ã™ã€‚"
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr ""
+ "<![CDATA[// in the first session
+\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);
+\n"
+ "
+\n"
+ "// in a higher tier of the application
+\n"
+ "Cat mate = new Cat();
+\n"
+ "cat.setMate(mate);
+\n"
+ "
+\n"
+ "// later, in a new session
+\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)
+\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr "<literal>saveOrUpdate()</literal> ã®ä½¿ç”¨æ–¹æ³•ã¨æ„味ã¯ã€ æ–°ã—ã„ユーザã«ã¨ã£ã¦æ··ä¹±ã‚’æ‹›ãã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã¾ãšç¬¬ä¸€ã«ã€ã‚るセッションã§ä½¿ç”¨ã—ãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’別ã®æ–°ã—ã„セッションã§ä½¿ãŠã†ã¨ã—ãªã„é™ã‚Šã€ <literal>update()</literal> ã‚„ <literal>saveOrUpdate()</literal> ã‚„ <literal>merge()</literal> を使ã†å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 アプリケーション全体を通ã˜ã¦ã€ã“れらã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’å…¨ã使ã‚ãªã„ã“ã¨ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr "通常〠<literal>update()</literal> ã‚„ <literal>saveOrUpdate()</literal> ã¯æ¬¡ã®ã‚·ãƒŠãƒªã‚ªã§ 使ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr "アプリケーションãŒæœ€åˆã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§ã‚ªãƒ–ジェクトをãƒãƒ¼ãƒ‰ã—ã¾ã™ã€‚"
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr "オブジェクトãŒUI層ã«é€ã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr "オブジェクトã«å¯¾ã—ã¦å¤‰æ›´ãŒåŠ ãˆã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr "オブジェクトãŒãƒ“ジãƒã‚¹ãƒã‚¸ãƒƒã‚¯å±¤ã«é€ã‚‰ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr "アプリケーションã¯ã€2番目ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§ <literal>update()</literal> を呼ã¶ã“ã¨ã§ã€ã“れらã®å¤‰æ›´ã‚’永続化ã—ã¾ã™ã€‚"
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr "<literal>saveOrUpdate()</literal> ã¯ä»¥ä¸‹ã®ã“ã¨ã‚’è¡Œã„ã¾ã™ã€‚"
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr "オブジェクトãŒã“ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã§ã€ã™ã§ã«æ°¸ç¶šåŒ–ã•ã‚Œã¦ã„ã‚Œã°ã€ä½•ã‚‚ã—ã¾ã›ã‚“。"
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr "ãã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«é–¢é€£ã¥ã„ã¦ã„る別ã®ã‚ªãƒ–ジェクトãŒåŒã˜è˜åˆ¥åã‚’æŒã£ã¦ã„ã‚‹ãªã‚‰ã€ 例外を投ã’ã¾ã™ã€‚"
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr "オブジェクトã®è˜åˆ¥åãŒå€¤ã‚’æŒãŸãªã„ãªã‚‰ã°ã€ <literal>save()</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr "オブジェクトã®è˜åˆ¥åãŒå€¤ã‚’æŒã¡ã€ãã®å€¤ãŒæ–°ãŸã«ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹åŒ–ã•ã‚ŒãŸã‚ªãƒ–ジェクトã®ãŸã‚ã®å€¤ã§ã‚ã‚‹å ´åˆã€ ãã®ã‚ªãƒ–ジェクトを <literal>save()</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr "オブジェクトãŒï¼ˆ <literal><version></literal> ã‚„ <literal><timestamp></literal> ã«ã‚ˆã£ã¦ï¼‰ ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¥ã‘ã•ã‚Œã¦ã„ã¦ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã®ãƒ—ãƒãƒ‘ティãŒå€¤ã‚’æŒã¡ã€ ãã®å€¤ãŒæ–°ã—ãインスタンス化ã•ã‚ŒãŸã‚ªãƒ–ジェクトã®ãŸã‚ã®å€¤ã§ã‚ã‚‹å ´åˆã€ ãã®ã‚ªãƒ–ジェクトを <literal>save()</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "ãã†ã§ãªã„å ´åˆã¯ã€ãã®ã‚ªãƒ–ジェクトを <literal>update()</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "ãã—ã¦ã€ <literal>merge()</literal> ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ã¨ã¦ã‚‚ç•°ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr "åŒã˜è˜åˆ¥åã‚’æŒã¤æ°¸ç¶šåŒ–インスタンスãŒãã®æ™‚点ã§ã‚»ãƒƒã‚·ãƒ§ãƒ³ã¨é–¢é€£ä»˜ã„ã¦ã„ã‚‹ãªã‚‰ã°ã€ 引数ã§å—ã‘å–ã£ãŸã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã‚’永続化インスタンスã«ã‚³ãƒ”ーã—ã¾ã™ã€‚"
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr "永続化インスタンスãŒãã®æ™‚点ã§ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«é–¢é€£ä»˜ã„ã¦ã„ãªã„ãªã‚‰ã€ データベースã‹ã‚‰ãれをãƒãƒ¼ãƒ‰ã™ã‚‹ã‹ã€ã‚ã‚‹ã„ã¯ã€æ–°ã—ã„永続化インスタンスを作æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr "永続化インスタンスãŒè¿”ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr "引数ã¨ã—ã¦ä¸ŽãˆãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã‚»ãƒƒã‚·ãƒ§ãƒ³ã¨é–¢é€£ã‚’æŒã¡ã¾ã›ã‚“。 ãã‚Œã¯ã€åˆ†é›¢çŠ¶æ…‹ã®ã¾ã¾ã§ã™ã€‚"
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr "永続オブジェクトã®å‰Šé™¤"
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr "<literal>Session.delete()</literal> ã¯ã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã‚’データベースã‹ã‚‰å‰Šé™¤ã—ã¾ã™ã€‚ ã‚‚ã¡ã‚ã‚“ã€å‰Šé™¤ã—ãŸã‚ªãƒ–ジェクトをアプリケーションãŒä¿æŒã—ãŸã¾ã¾ã§ã‚‚よã„ã§ã™ã€‚ ãã®ãŸã‚〠<literal>delete()</literal> ã¯æ°¸ç¶šã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’一時的ã«ã™ã‚‹ã‚‚ã®ã¨è€ƒãˆã‚‹ã®ãŒä¸€ç•ªã§ã™ã€‚"
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr "<![CDATA[sess.delete(cat);]]>"
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr "外部ã‚ー制約ã«é•åã™ã‚‹ãƒªã‚¹ã‚¯ã‚‚ãªãã€å¥½ããªé †ç•ªã§ã‚ªãƒ–ジェクトを削除ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ãŸã ã—ã€é–“é•ã£ãŸé †ç•ªã§ã‚ªãƒ–ジェクトを削除ã™ã‚‹ã¨ã€å¤–部ã‚ーカラム㮠<literal>NOT NULL</literal> 制約ã«é•åã™ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚ 例ãˆã°ã€è¦ªã‚ªãƒ–ジェクトを削除ã—ãŸã¨ãã«ã€å供オブジェクトを削除ã—忘れãŸå ´åˆã§ã™ã€‚"
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr "ç•°ãªã‚‹äºŒã¤ã®ãƒ‡ãƒ¼ã‚¿ã‚¹ãƒˆã‚¢é–“ã§ã®ã‚ªãƒ–ジェクトã®ãƒ¬ãƒ—リケーション"
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr "永続インスタンスã®ã‚°ãƒ©ãƒ•ã‚’別ã®ãƒ‡ãƒ¼ã‚¿ã‚¹ãƒˆã‚¢ã«æ°¸ç¶šåŒ–ã™ã‚‹å ´åˆã«ã€ è˜åˆ¥åã®å€¤ã‚’å†ç”Ÿæˆã›ãšã«ã™ã‚€ã¨ä¾¿åˆ©ãªå ´åˆãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr ""
+ "<![CDATA[//retrieve a cat from one database
+\n"
+ "Session session1 = factory1.openSession();
+\n"
+ "Transaction tx1 = session1.beginTransaction();
+\n"
+ "Cat cat = session1.get(Cat.class, catId);
+\n"
+ "tx1.commit();
+\n"
+ "session1.close();
+\n"
+ "
+\n"
+ "//reconcile with a second database
+\n"
+ "Session session2 = factory2.openSession();
+\n"
+ "Transaction tx2 = session2.beginTransaction();
+\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);
+\n"
+ "tx2.commit();
+\n"
+ "session2.close();]]>"
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr "レプリケーション先ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«è¡ŒãŒæ—¢ã«ã‚ã‚‹å ´åˆã€ <literal>replicate()</literal> ãŒè¡çªã‚’ã©ã®ã‚ˆã†ã«æ‰±ã†ã‹ã‚’ <literal>ReplicationMode</literal> ã§æŒ‡å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr "<literal>ReplicationMode.IGNORE</literal> - åŒã˜è˜åˆ¥åã‚’æŒã¤è¡ŒãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«å˜åœ¨ã™ã‚‹ãªã‚‰ã€ ãã®ã‚ªãƒ–ジェクトを無視ã—ã¾ã™ã€‚"
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr "<literal>ReplicationMode.OVERWRITE</literal> - åŒã˜è˜åˆ¥åã‚’æŒã¤æ—¢å˜ã®è¡Œã‚’ ã™ã¹ã¦ä¸Šæ›¸ãã—ã¾ã™ã€‚"
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.EXCEPTION</literal> - åŒã˜è˜åˆ¥åã‚’æŒã¤è¡ŒãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«å˜åœ¨ã™ã‚‹ãªã‚‰ã€ 例外を投ã’ã¾ã™ã€‚"
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.LATEST_VERSION</literal> - è¡Œã«ä¿å˜ã•ã‚Œã¦ã„ã‚‹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ãŒã€ 引数ã®ã‚ªãƒ–ジェクトã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã‚ˆã‚Šå¤ã„ãªã‚‰ã°ã€ãã®è¡Œã‚’上書ãã—ã¾ã™ã€‚"
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr "次ã®ã‚ˆã†ãªã‚±ãƒ¼ã‚¹ã§ã€ã“ã®æ©Ÿèƒ½ã‚’使用ã—ã¾ã™ã€‚ ç•°ãªã‚‹ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã«å…¥ã‚Œã‚‰ã‚ŒãŸãƒ‡ãƒ¼ã‚¿ã®åŒæœŸã€ 製å“更新時ã«ãŠã‘るシステムè¨å®šæƒ…å ±ã®æ›´æ–°ã€éžACIDトランザクションã®ãªã‹ã§åŠ ãˆã‚‰ã‚ŒãŸå¤‰æ›´ã®ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ãªã©ã§ã™ã€‚"
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr "セッションã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥"
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr "JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã®çŠ¶æ…‹ã¨ãƒ¡ãƒ¢ãƒªä¸Šã®ã‚ªãƒ–ジェクトã®çŠ¶æ…‹ã‚’åŒæœŸã•ã›ã‚‹ãŸã‚ã«å¿…è¦ãª SQL文を <literal>Session</literal> ãŒå®Ÿè¡Œã™ã‚‹ã“ã¨ãŒã¨ãã©ãã‚ã‚Šã¾ã™ã€‚ ã“ã®å‡¦ç† <emphasis>flush</emphasis> ã¯ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯æ¬¡ã®ã¨ãã«èµ·ã“ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr "クエリを実行ã™ã‚‹å‰"
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr "<literal>org.hibernate.Transaction.commit()</literal> を実行ã—ãŸã¨ã"
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr "<literal>Session.flush()</literal> を実行ã—ãŸã¨ã"
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr "SQLæ–‡ã¯ä»¥ä¸‹ã®é †ç•ªã§ç™ºè¡Œã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr "ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®æŒ¿å…¥ã€‚ã“ã‚Œã¯ã€ <literal>Session.save()</literal> を使ã£ã¦ã‚»ãƒ¼ãƒ–ã—㟠オブジェクトã®é †ã«å®Ÿè¡Œã—ã¦ã„ãã¾ã™ã€‚"
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr "ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®æ›´æ–°"
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr "ã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å‰Šé™¤"
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr "ã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®è¦ç´ ã«å¯¾ã™ã‚‹å‰Šé™¤ã€æ›´æ–°ã€æŒ¿å…¥"
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr "ã™ã¹ã¦ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®æŒ¿å…¥"
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr "ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å‰Šé™¤ã€‚ã“ã‚Œã¯ã€<literal>Session.delete()</literal> を使ã£ã¦ 削除ã—ãŸã‚ªãƒ–ジェクトã®é †ã«å®Ÿè¡Œã—ã¦ã„ãã¾ã™ã€‚"
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr "(１ã¤ä¾‹å¤–ãŒã‚ã‚Šã¾ã™ã€‚ <literal>native</literal> ID 生æˆã‚’使ã£ãŸã‚ªãƒ–ジェクトã¯ã€ ãれらãŒã‚»ãƒ¼ãƒ–ã•ã‚ŒãŸã¨ãã«æŒ¿å…¥ã•ã‚Œã¾ã™ã€‚）"
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr "明示的㫠<literal>flush()</literal> ã™ã‚‹ã¨ãを除ã„ã¦ã€ <emphasis>ã„ã¤</emphasis> <literal>Session</literal> ãŒJDBCをコールã™ã‚‹ã®ã‹ã«ã¤ã„㦠絶対的ãªä¿è¨¼ã¯ã‚ã‚Šã¾ã›ã‚“。ãŸã ã—ã€ãれらãŒå®Ÿè¡Œã•ã‚Œã‚‹ <emphasis>é †ç•ª</emphasis> ã ã‘㯠ä¿è¨¼ã•ã‚Œã¾ã™ã€‚ ã¾ãŸã€Hibernate ã¯ã€ <literal>Query.list(..)</literal> ãŒå¤ã„データや間é•ã£ãŸãƒ‡ãƒ¼ã‚¿è¿”ã•ãªã„ã“ã¨ã‚’ ä¿è¨¼ã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr "フラッシュãŒé »ç¹ã«èµ·ã“らãªã„よã†ã«ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®æŒ¯ã‚‹èˆžã„を変ãˆã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal>FlushMode</literal> クラスã¯3ã¤ã®ç•°ãªã‚‹ãƒ¢ãƒ¼ãƒ‰ã‚’定義ã—ã¾ã™ã€‚ ãã‚Œã¯ã€ã‚³ãƒŸãƒƒãƒˆæ™‚ã«ã ã‘フラッシュã™ã‚‹ãƒ¢ãƒ¼ãƒ‰ （Hibernateã® <literal>Transaction</literal> APIãŒä½¿ã‚ã‚Œã‚‹å ´åˆã ã‘ã§ã™ï¼‰ã€ 説明ã®ã‚ã£ãŸå‡¦ç†é †ã«åŸºã¥ã„ã¦è‡ªå‹•ã§ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã™ã‚‹ãƒ¢ãƒ¼ãƒ‰ã€ <literal>flush()</literal> ãŒæ˜Žç¤ºçš„ã«å‘¼ã°ã‚Œãªã„é™ã‚Šãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã—ãªã„モードã®ï¼“ã¤ã§ã™ã€‚ 最後ã®ãƒ¢ãƒ¼ãƒ‰ã¯ã€ä½œæ¥å˜ä½ãŒé•·æœŸé–“ã«åŠã¶å ´åˆã«å½¹ã«ç«‹ã¡ã¾ã™ ( <xref linkend=\"transactions-optimistic-longsession\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„)。"
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr ""
+ "<![CDATA[sess = sf.openSession();
+\n"
+ "Transaction tx = sess.beginTransaction();
+\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state
+\n"
+ "
+\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);
+\n"
+ "izi.setName(iznizi);
+\n"
+ "
+\n"
+ "// might return stale data
+\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");
+\n"
+ "
+\n"
+ "// change to izi is not flushed!
+\n"
+ "...
+\n"
+ "tx.commit(); // flush occurs
+\n"
+ "sess.close();]]>"
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr "フラッシュã®ã¨ãã€ä¾‹å¤–ãŒç™ºç”Ÿã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 （例ãˆã°ã€DMLæ“作ãŒåˆ¶ç´„ã‚’é•åã™ã‚‹ã‚ˆã†ãªå ´åˆã§ã™ã€‚） 例外処ç†ã‚’ç†è§£ã™ã‚‹ãŸã‚ã«ã¯ã€Hibernateã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®æŒ¯ã‚‹èˆžã„ã‚’ç†è§£ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãŸã‚〠<xref linkend=\"transactions\"/> ã§èª¬æ˜Žã—ã¾ã™ã€‚"
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr "連鎖的ãªæ°¸ç¶šåŒ–"
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr "個々ã®ã‚ªãƒ–ジェクトをセーブã—ãŸã‚Šã€å‰Šé™¤ã—ãŸã‚Šã€å†è¿½åŠ ã—ãŸã‚Šã™ã‚‹ã“ã¨ã¯ ã‹ãªã‚Šé¢å€’ã§ã™ã€‚特ã«ã€é–¢é€£ã™ã‚‹ã‚ªãƒ–ジェクトを扱ã†ã‚ˆã†ãªå ´åˆã«ã¯éš›ç«‹ã¡ã¾ã™ã€‚ よãã‚ã‚‹ã®ã¯ã€è¦ªå関係を扱ã†ã‚±ãƒ¼ã‚¹ã§ã™ã€‚ 以下ã®ä¾‹ã‚’考ãˆã¦ã¿ã¾ã—ょã†ã€‚"
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr "ã‚‚ã—ã€è¦ªå関係ã®åãŒå€¤åž‹ãªã‚‰ï¼ˆä¾‹ãˆã°ã€ä½æ‰€ã‚„æ–‡å—列ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ï¼‰ã€ ãれらã®ãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã¯è¦ªã«ä¾å˜ã—ã¦ãŠã‚Šã€ä¾¿åˆ©ãªçŠ¶æ…‹å¤‰åŒ–ã®\"カスケード\"を使ã†ãŸã‚ã«ã€ è¿½åŠ ã®ä½œæ¥ã¯å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 親ãŒã‚»ãƒ¼ãƒ–ã•ã‚ŒãŸã¨ãã€å€¤åž‹ã®åオブジェクトもåŒã˜ã‚ˆã†ã«ã‚»ãƒ¼ãƒ–ã•ã‚Œã¾ã™ã—〠親ãŒå‰Šé™¤ã•ã‚ŒãŸã¨ãã¯ã€åも削除ã•ã‚Œã¾ã™ã€‚ãã®ä»–ã®æ“作もåŒã˜ã§ã™ã€‚ コレクションã‹ã‚‰1ã¤ã®åを削除ã™ã‚‹ã‚ˆã†ãªæ“作ã§ã‚‚ã†ã¾ãã„ãã¾ã™ã€‚ ã™ãªã‚ã¡ã€Hibernateã¯ã“ã®å‰Šé™¤æ“作を検出ã™ã‚‹ã¨ã€ 値型ã®ã‚ªãƒ–ジェクトã¯å‚照を共有ã§ããªã„ã®ã§ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰ãã®å供を削除ã—ã¾ã™ã€‚"
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr "ã“ã“ã§ã€è¦ªã¨åãŒå€¤åž‹ã§ãªãエンティティã§ã‚ã‚‹ã¨ã—ã¦åŒã˜ã‚·ãƒŠãƒªã‚ªã‚’考ãˆã¦ã¿ã¾ã—ょã†ã€‚ （例ãˆã°ã€ã‚«ãƒ†ã‚´ãƒªãƒ¼ã¨å“ç›®ã®é–¢ä¿‚や親ã¨åã®çŒ«ã®é–¢ä¿‚ã§ã™ã€‚） エンティティã¯ã€ãれ自身ãŒãƒ©ã‚¤ãƒ•ã‚µã‚¤ã‚¯ãƒ«ã‚’æŒã¡ã€å‚ç…§ã®å…±æœ‰ã‚’サãƒãƒ¼ãƒˆã—ã¾ã™ã€‚ （ãã®ãŸã‚ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‹ã‚‰ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚’削除ã™ã‚‹ã“ã¨ã¯ã€ エンティティ自身ã®å‰Šé™¤ã‚’æ„味ã—ã¾ã›ã‚“。） ã¾ãŸã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¯ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã§ã¯ã€é–¢é€£ã™ã‚‹ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ 状態をカスケードã™ã‚‹ã“ã¨ã¯ã‚ã‚Šã¾ã›ã‚“。 Hibernate㯠<emphasis>到é”å¯èƒ½æ€§ã«ã‚ˆã‚‹æ°¸ç¶šåŒ–</emphasis> をデフォルトã§ã¯å®Ÿè¡Œã—ã¾ã›ã‚“。"
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr "Hibernateã®Sessionã®åŸºæœ¬æ“作（ <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> ãŒå«ã¾ã‚Œã¾ã™ï¼‰ã«å¯¾ã—ã¦ã€ ãã‚Œãžã‚Œã«å¯¾å¿œã™ã‚‹ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã‚¹ã‚¿ã‚¤ãƒ«ãŒã‚ã‚Šã¾ã™ã€‚ ãã‚Œãžã‚Œã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã‚¹ã‚¿ã‚¤ãƒ«ã«ã¯ã€ <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal> ã¨ã„ã†åå‰ãŒã¤ã„ã¦ã„ã¾ã™ã€‚ ã‚‚ã—ã€é–¢é€£ã«æ²¿ã£ã¦ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã•ã›ãŸã„æ“作ãŒã‚ã‚‹ãªã‚‰ã€ãƒžãƒƒãƒ”ングファイルã«ãã†æŒ‡å®šã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 例ãˆã°ã€ä»¥ä¸‹ã®ã‚ˆã†ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr "カスケードスタイルã¯ã€çµ„ã¿åˆã‚ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr "<emphasis>ã™ã¹ã¦ã®</emphasis> æ“作を関連ã«æ²¿ã£ã¦ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã™ã‚‹ã‚ˆã†æŒ‡å®šã™ã‚‹ã¨ãã¯ã€ <literal>cascade=\"all\"</literal> を使ã„ã¾ã™ã€‚ デフォルト㮠<literal>cascade=\"none\"</literal> ã¯ã€ã©ã®æ“作もカスケードã—ãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr "特殊ãªã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã‚¹ã‚¿ã‚¤ãƒ« <literal>delete-orphan</literal> ã¯ã€ä¸€å¯¾å¤šé–¢é€£ã«ã ã‘ é©ç”¨ã§ãã¾ã™ã€‚ ã“ã‚Œã¯ã€é–¢é€£ã‹ã‚‰å‰Šé™¤ã•ã‚ŒãŸåä¾›ã®ã‚ªãƒ–ジェクトã«å¯¾ã—ã¦ã€ <literal>delete()</literal> æ“作ãŒé©ç”¨ã•ã‚Œã‚‹ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr "ãŠã™ã™ã‚："
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr "普通〠<literal><many-to-one></literal> ã‚„ <literal><many-to-many></literal> 関連ã«å¯¾ã—ã¦ã¯ã€ カスケードをè¨å®šã™ã‚‹æ„味ã¯ã‚ã‚Šã¾ã›ã‚“。 <literal><one-to-one></literal> 㨠<literal><one-to-many></literal> 関連ã«å¯¾ã—ã¦ã¯ã€ カスケードãŒå½¹ã«ç«‹ã¤ã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr "å供オブジェクトã®å¯¿å‘½ãŒè¦ªã‚ªãƒ–ジェクトã®å¯¿å‘½ã«åˆ¶é™ã‚’å—ã‘ã‚‹ãªã‚‰ã°ã€ <literal>cascade=\"all,delete-orphan\"</literal> を指定ã—〠å供オブジェクトを <emphasis>ライフサイクルオブジェクト</emphasis> ã«ã—ã¾ã™ã€‚"
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr ". ãれ以外ã®å ´åˆã¯ã€ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã¯ã»ã¨ã‚“ã©å¿…è¦ãªã„ã§ã—ょã†ã€‚ ã—ã‹ã—ã€åŒã˜ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ãªã‹ã§è¦ªã¨åãŒä¸€ç·’ã«å‹•ä½œã™ã‚‹ã“ã¨ãŒå¤šã„ã¨æ€ã„〠ã„ãらã‹ã®ã‚³ãƒ¼ãƒ‰ã‚’書ã手間をçœããŸã„ã®ã§ã‚ã‚Œã°ã€ <literal>cascade=\"persist,merge,save-update\"</literal> を使ã†ã“ã¨ã‚’考ãˆã¾ã—ょã†ã€‚"
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr "<literal>cascade=\"all\"</literal> ã§ãƒžãƒƒãƒ”ングã—ãŸé–¢é€£ï¼ˆå˜å€¤é–¢é€£ã‚„コレクション）ã¯ã€ <emphasis>親å</emphasis> スタイルã®é–¢é€£ã¨ãƒžãƒ¼ã‚¯ã•ã‚Œã¾ã™ã€‚ ãã‚Œã¯ã€è¦ªã®ã‚»ãƒ¼ãƒ–/æ›´æ–°/削除ãŒã€åã®ã‚»ãƒ¼ãƒ–/æ›´æ–°/削除を引ãèµ·ã“ã™é–¢ä¿‚ã®ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr "ã•ã‚‰ã«ã€æ°¸ç¶šåŒ–ã•ã‚ŒãŸè¦ªãŒåã‚’å˜ã«å‚ç…§ã—ã¦ã„ã‚‹ã ã‘ã§ã€åã®ã‚»ãƒ¼ãƒ–/更新を引ãèµ·ã“ã—ã¾ã™ã€‚ ã—ã‹ã—ã€ã“ã®ãƒ¡ã‚¿ãƒ•ã‚¡ãƒ¼ã¯ä¸å®Œå…¨ã§ã™ã€‚親ã‹ã‚‰å‚ç…§ã•ã‚Œãªããªã£ãŸåã¯ã€è‡ªå‹•çš„ã«å‰Šé™¤ <emphasis>ã•ã‚Œã¾ã›ã‚“</emphasis> 。 ãŸã ã—〠<literal>cascade=\"delete-orphan\"</literal> ã§ãƒžãƒƒãƒ”ングã•ã‚ŒãŸ <literal><one-to-many></literal> 関連を 除ã„ã¦ã§ã™ã€‚ 親å関係ã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰æ“作ã®æ£ç¢ºãªæ„味ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr "親㌠<literal>persist()</literal> ã«æ¸¡ã•ã‚ŒãŸãªã‚‰ã°ã€ ã™ã¹ã¦ã®å㯠<literal>persist()</literal> ã«æ¸¡ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr "<literal>merge()</literal> ã«æ¸¡ã•ã‚ŒãŸãªã‚‰ã°ã€ ã™ã¹ã¦ã®å㯠<literal>merge()</literal> ã«æ¸¡ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr "親㌠<literal>save()</literal> 〠<literal>update()</literal> 〠<literal>saveOrUpdate()</literal> ã«æ¸¡ã•ã‚ŒãŸãªã‚‰ã°ã€ã™ã¹ã¦ã®å㯠<literal>saveOrUpdate()</literal> ã«æ¸¡ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr "一時的ã¾ãŸã¯åˆ†é›¢çŠ¶æ…‹ã®åãŒã€æ°¸ç¶šåŒ–ã•ã‚ŒãŸè¦ªã«å‚ç…§ã•ã‚ŒãŸãªã‚‰ã°ã€ <literal>saveOrUpdate()</literal> ã«æ¸¡ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr "親ãŒå‰Šé™¤ã•ã‚ŒãŸãªã‚‰ã°ã€ã™ã¹ã¦ã®åã¯ã€ <literal>delete()</literal> ã«æ¸¡ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr "åãŒæ°¸ç¶šåŒ–ã•ã‚ŒãŸè¦ªã‹ã‚‰å‚ç…§ã•ã‚Œãªããªã£ãŸã¨ãã¯ã€ <emphasis>特ã«ä½•ã‚‚èµ·ã“ã‚Šã¾ã›ã‚“</emphasis> 。 よã£ã¦ã€ã‚¢ãƒ—リケーションãŒå¿…è¦ã§ã‚ã‚Œã°ã€æ˜Žç¤ºçš„ã«å‰Šé™¤ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ãŸã ã—〠<literal>cascade=\"delete-orphan\"</literal> ã®å ´åˆã‚’除ãã¾ã™ã€‚ ã“ã®å ´åˆã€ã€Œè¦ªã®ãªã„ã€åã¯å‰Šé™¤ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr "最後ã«ã€æ“作ã®ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ãŒã‚ªãƒ–ジェクトグラフã«é©ç”¨ã•ã‚Œã‚‹ã®ã¯ã€ <emphasis>コールã—ãŸæ™‚</emphasis> ã‚ã‚‹ã„ã¯ã€ <emphasis>flushã—ãŸæ™‚</emphasis> ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã™ã¹ã¦ã®æ“作ã¯ã€ãã®æ“作ãŒå®Ÿè¡Œã•ã‚ŒãŸã¨ãã«ã€åˆ°é”å¯èƒ½ãªé–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«å¯¾ã—㦠カスケードãŒå¯èƒ½ãªã‚‰ã‚«ã‚¹ã‚±ãƒ¼ãƒ‰ã—ã¾ã™ã€‚ ã—ã‹ã—〠<literal>save-upate</literal> 㨠<literal>delete-orphan</literal> ã¯ã€ <literal>Session</literal> ãŒflushã—ã¦ã„ã‚‹é–“ã«ã€ ã™ã¹ã¦ã®åˆ°é”å¯èƒ½ãªé–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã«ä¼æ’ã—ã¾ã™ã€‚"
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr "メタデータã®ä½¿ç”¨"
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr "Hibernateã¯ã€ã™ã¹ã¦ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¨å€¤åž‹ã®éžå¸¸ã«ãƒªãƒƒãƒãªãƒ¡ã‚¿ãƒ¬ãƒ™ãƒ«ã®ãƒ¢ãƒ‡ãƒ«ã‚’å¿…è¦ã¨ã—ã¾ã™ã€‚ ã¨ãã©ãã€ã“ã®ãƒ¢ãƒ‡ãƒ«ã¯ã‚¢ãƒ—リケーションã«ã¨ã£ã¦ã¨ã¦ã‚‚å½¹ã«ç«‹ã¡ã¾ã™ã€‚ 例ãˆã°ã€ã‚¢ãƒ—リケーションã¯ã€Hibernateã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’使ã£ã¦ã€\"è³¢ã„\" ディープコピーアルゴリズムを 実装ã§ãã‚‹ã‹ã‚‚ã—ã¾ã›ã‚“。ãã®ã‚¢ãƒ«ã‚´ãƒªã‚ºãƒ ã¨ã¯ã€ã©ã®ã‚ªãƒ–ジェクトãŒã‚³ãƒ”ーã•ã‚Œã‚‹ã¹ãã‹ï¼ˆä¾‹ï¼šå¯å¤‰ã®å€¤åž‹ï¼‰ã‚„ ã©ã®ã‚ªãƒ–ジェクトã¯ã‚³ãƒ”ーã•ã‚Œãªã„ã¹ãã‹ï¼ˆä¾‹ï¼šä¸å¤‰ãªå€¤åž‹ã‚„å¯èƒ½ãªã‚‰é–¢é€£ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ï¼‰ã‚’ 判æ–ã§ãã‚‹ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr "Hibernateã¯<literal>ClassMetadata</literal> ã¨<literal>CollectionMetadata</literal> インタフェース㨠<literal>Type</literal> 階層を通ã—ã¦ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿ã‚’公開ã—ã¾ã™ã€‚ メタデータインターフェイスã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ <literal>SessionFactory</literal> ã‹ã‚‰å¾—られã¾ã™ã€‚"
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+ "<![CDATA[Cat fritz = ......;
+\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);
+\n"
+ "
+\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);
+\n"
+ "String[] propertyNames = catMeta.getPropertyNames();
+\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();
+\n"
+ "
+\n"
+ "// get a Map of all properties which are not collections or associations
+\n"
+ "Map namedValues = new HashMap();
+\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {
+\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {
+\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,807 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr "Toolset Guide ツールセットガイド"
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr "Hibernateを使ã£ãŸãƒ©ã‚¦ãƒ³ãƒ‰ãƒˆãƒªãƒƒãƒ—エンジニアリングã¯ã€ Eclipseプラグインやコマンドラインツールã€ã‚‚ã¡ã‚ã‚“Antタスクを使ã†ã“ã¨ã§å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "<emphasis>Hibernate Tools</emphasis> ã¯ç¾åœ¨ã€æ—¢å˜ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ãƒªãƒãƒ¼ã‚¹ã‚¨ãƒ³ã‚¸ãƒ‹ã‚¢ãƒªãƒ³ã‚°ã®Antタスクã«åŠ ãˆã¦ã€EclipseIDEã®ãƒ—ラグインをå«ã¿ã¾ã™ã€‚"
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr "<emphasis>マッピングエディタ:</emphasis> Hibernateã®XMLマッピングファイル用ã®ã‚¨ãƒ‡ã‚£ã‚¿ã§ã€ 自動補完ã¨æ§‹æ–‡å¼·èª¿è¡¨ç¤ºã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚クラスåやプãƒãƒ‘ティ/フィールドåã«å¯¾ã™ã‚‹è‡ªå‹•è£œå®Œã‚‚サãƒãƒ¼ãƒˆã—〠通常ã®XMLエディタよりも強力ã§ã™ã€‚"
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>Console:</emphasis> コンソールã¯ã‚¨ã‚¯ãƒªãƒ—スã®æ–°ã—ã„ビューã§ã™ã€‚ コンソールコンフィギュレーションã®ãƒ„リーオーãƒãƒ¼ãƒ“ューã«åŠ ãˆã¦ã€æ°¸ç¶šã‚¯ãƒ©ã‚¹ã¨ãã®é–¢é€£ã®ç›¸äº’作用ビューも得られã¾ã™ã€‚ データベースã«HQLを実行ã—ã€çµæžœã‚’直接エクリプス上ã§è¦‹ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>開発ウィザード</emphasis> Hibernateã®Eclipseツールã¯ã„ãã¤ã‹ã®ã‚¦ã‚£ã‚¶ãƒ¼ãƒ‰ã‚’æä¾›ã—ã¾ã™ã€‚ ウィザードを使ã£ã¦Hibernateã®è¨å®šãƒ•ã‚¡ã‚¤ãƒ«(cfg.xml)ã‚’ã™ã°ã‚„ã生æˆã—ãŸã‚Šã€ æ—¢å˜ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマをPOJOã®ã‚½ãƒ¼ã‚¹ãƒ•ã‚¡ã‚¤ãƒ«ã¨Hibernateã®ãƒžãƒƒãƒ”ングファイルã¸ã¨ã€ 完全ã«ãƒªãƒãƒ¼ã‚¹ã‚¨ãƒ³ã‚¸ãƒ‹ã‚¢ãƒªãƒ³ã‚°ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ リãƒãƒ¼ã‚¹ã‚¨ãƒ³ã‚¸ãƒ‹ã‚¢ãƒªãƒ³ã‚°ã‚¦ã‚£ã‚¶ãƒ¼ãƒ‰ã¯ã‚«ã‚¹ã‚¿ãƒžã‚¤ã‚ºå¯èƒ½ãªãƒ†ãƒ³ãƒ—レートをサãƒãƒ¼ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr "Ant Tasks:"
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr "より詳ã—ã„æƒ…å ±ã¯ <emphasis>Hibernate Tools</emphasis> パッケージã¨ãã®ãƒ‰ã‚ュメントをå‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr "ã—ã‹ã—ã€Hibernateã®ãƒ¡ã‚¤ãƒ³ãƒ‘ッケージ㯠<emphasis>SchemaExport</emphasis> 〠別å <literal>hbm2ddl</literal> ã‚‚å«ã¿ã¾ã™(Hibernate内ã§ã‚ªãƒ³ã‚¶ãƒ•ãƒ©ã‚¤ã§ä½¿ç”¨ã§ãã¾ã™)。"
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr "スã‚ーマã®è‡ªå‹•ç”Ÿæˆ"
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "DDLã¯Hibernateユーティリティã«ã‚ˆã‚Šãƒžãƒƒãƒ”ングファイルã‹ã‚‰ç”Ÿæˆã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ 生æˆã•ã‚ŒãŸã‚¹ã‚ーマã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚„コレクションã®ãƒ†ãƒ¼ãƒ–ルã«å¯¾ã™ã‚‹å‚照整åˆæ€§åˆ¶ç´„(主ã‚ーã¨å¤–部ã‚ー)ã‚’å«ã¿ã¾ã™ã€‚ テーブルã¨ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ã¯ãƒžãƒƒãƒ”ングã™ã‚‹è˜åˆ¥åジェãƒãƒ¬ãƒ¼ã‚¿ã«å¯¾ã—ã¦ç”Ÿæˆã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr "DDLã¯ãƒ™ãƒ³ãƒ€ãƒ¼ä¾å˜ãªã®ã§ã€ã“ã®ãƒ„ールを使ã†ã¨ãã¯ã€<literal>hibernate.dialect</literal> プãƒãƒ‘ティã§SQLã® <literal>方言</literal> を指定 <emphasis>ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“</emphasis> 。"
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr "ã¾ãšã€ç”Ÿæˆã•ã‚Œã‚‹ã‚¹ã‚ーマを改善ã™ã‚‹ã‚ˆã†ã«ã€ãƒžãƒƒãƒ”ングファイルをカスタマイズã—ã¦ãã ã•ã„。"
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr "スã‚ーマã®ã‚«ã‚¹ã‚¿ãƒžã‚¤ã‚º"
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr "多ãã®Hibernateã®ãƒžãƒƒãƒ”ングè¦ç´ ã§ã¯ã€ã‚ªãƒ—ション㮠<literal>length</literal> ã¨ã„ã†åã®å±žæ€§ã‚’定義ã—ã¦ã„ã¾ã™ã€‚ ã“ã®å±žæ€§ã§ã‚«ãƒ©ãƒ é•·ã‚’è¨å®šã™ã‚‹ã“ã¨ãŒã§ãã¾ã™(ã¾ãŸã¯NUMERIC/DECIMALåž‹ã®ãƒ‡ãƒ¼ã‚¿ã®ç²¾åº¦ã‚’è¨å®šã§ãã¾ã™)。"
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr "<literal>not-null</literal> 属性（テーブルã®ã‚«ãƒ©ãƒ 㸠<literal>NOT NULL</literal> 制約を生æˆã™ã‚‹ï¼‰ã¨ <literal>unique</literal> 属性（テーブルã®ã‚«ãƒ©ãƒ 㸠<literal>UNIQUE</literal> 制約を生æˆã™ã‚‹ï¼‰ãŒè¨å®šã§ãã‚‹ã‚¿ã‚°ã‚‚ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr "<literal>unique-key</literal> 属性ã¯ã‚«ãƒ©ãƒ をグループ化ã—ã¦ä¸€ã¤ã®ã‚ー制約ã«ã™ã‚‹ãŸã‚ã«ä½¿ã‚ã‚Œã¾ã™ã€‚ ç¾åœ¨ã€<literal>unique-key</literal> 属性ã§æŒ‡å®šã•ã‚ŒãŸå€¤ã¯åˆ¶ç´„ã®æŒ‡å®šã«ã¯ <emphasis>使ã‚ã‚Œãš</emphasis> 〠マッピングファイルã§ã‚«ãƒ©ãƒ をグループ化ã™ã‚‹ã“ã¨ã«ã®ã¿ä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>
+\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployeeId\"/>]]>"
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr "<literal>index</literal> 属性ã¯ãƒžãƒƒãƒ”ングã™ã‚‹ã‚«ãƒ©ãƒ を使ã£ã¦ç”Ÿæˆã—ãŸã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã®åå‰ã‚’指定ã—ã¾ã™ã€‚ 複数カラムを１ã¤ã®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã«ã‚°ãƒ«ãƒ¼ãƒ—化ã§ãã¾ã™ã€‚å˜ã«ã€åŒã˜ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹åを指定ã™ã‚‹ã ã‘ã§ã™ã€‚"
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>
+\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr "<literal>foreign-key</literal> 属性ã¯ã€ç”Ÿæˆã•ã‚ŒãŸå¤–部ã‚ー制約ã®åå‰ã‚’オーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã™ã‚‹ãŸã‚ã«ä½¿ç”¨ã§ãã¾ã™ã€‚"
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr "多ãã®ãƒžãƒƒãƒ”ングè¦ç´ ã¯ã€å <literal><column></literal> è¦ç´ を記述ã§ãã¾ã™ã€‚ã“ã‚Œã¯è¤‡æ•°ã‚«ãƒ©ãƒ åž‹ã®ãƒžãƒƒãƒ”ングã«ã¯ç‰¹ã«æœ‰ç”¨ã§ã™ã€‚"
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>
+\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>
+\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>
+\n"
+ " <column name=\"initial\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "<literal>default</literal> 属性ã¯ã‚«ãƒ©ãƒ ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã‚’指定ã—ã¾ã™ (マッピングã—ãŸã‚¯ãƒ©ã‚¹ã®æ–°ã—ã„インスタンスをä¿å˜ã™ã‚‹å‰ã«ã€ マッピングã—ãŸãƒ—ãƒãƒ‘ティã¸åŒã˜å€¤ã‚’代入ã™ã¹ãã§ã™)。"
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">
+\n"
+ " <column name=\"credits\" default=\"10\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">
+\n"
+ " <column name=\"version\" default=\"0\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr "<literal>sql-type</literal> 属性ã§ã€ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®Hibernateåž‹ã‹ã‚‰SQLã®ãƒ‡ãƒ¼ã‚¿åž‹ã¸ã®ãƒžãƒƒãƒ”ングをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã§ãã¾ã™ã€‚"
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">
+\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "<literal>check</literal> 属性ã§ãƒã‚§ãƒƒã‚¯åˆ¶ç´„を指定ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">
+\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>
+\n"
+ "</property>]]>"
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">
+\n"
+ " ...
+\n"
+ " <property name=\"bar\" type=\"float\"/>
+\n"
+ "</class>]]>"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr "<title>ã¾ã¨ã‚</title>"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr "<entry>属性</entry>"
+
+#: index.docbook:156
+msgid "Summary"
+msgstr "<entry>値</entry>"
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:164
+msgid "Values"
+msgstr "length"
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr "<entry>数値</entry>"
+
+#: index.docbook:170
+msgid "length"
+msgstr "カラムã®é•·ã•"
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr "precision"
+
+#: index.docbook:172
+msgid "column length"
+msgstr "<entry>数値</entry>"
+
+#: index.docbook:175
+msgid "precision"
+msgstr "カラムã®DECIMALåž‹ã®ç²¾åº¦ï¼ˆprecision）"
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr "<entry>数値</entry>"
+
+#: index.docbook:180
+msgid "scale"
+msgstr "カラムã®DECIMALåž‹ã®ã‚¹ã‚±ãƒ¼ãƒ«ï¼ˆscale）"
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr "true|false"
+
+#: index.docbook:185
+msgid "not-null"
+msgstr "カラムãŒnull値をå–らãªã„ã“ã¨ã‚’指定ã—ã¾ã™"
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr "unique"
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr "true|false"
+
+#: index.docbook:190
+msgid "unique"
+msgstr "カラムãŒãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ã‚’æŒã¤ã“ã¨ã‚’指定ã—ã¾ã™"
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr "インデックスå"
+
+#: index.docbook:195
+msgid "index"
+msgstr "(複数カラムã®)インデックスã®åå‰ã‚’指定ã—ã¾ã™"
+
+#: index.docbook:196
+msgid "index_name"
+msgstr "unique-key"
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr "ユニークã‚ーå"
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr "複数カラムã®ãƒ¦ãƒ‹ãƒ¼ã‚¯åˆ¶ç´„ã®åå‰ã‚’指定ã—ã¾ã™"
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr "foreign-key"
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr "外部ã‚ーå"
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr "<one-to-one>ã€<many-to-one>ã€<many-to-many>マッピングè¦ç´ を使ã£ã¦ã€ 関連ã«å¯¾ã—生æˆã•ã‚ŒãŸå¤–部ã‚ー制約ã®åå‰ã‚’指定ã—ã¾ã™ã€‚ <literal>SchemaExport</literal> 㯠<literal>inverse=\"true\"</literal> å´ã‚’考慮ã—ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr "sql-type"
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "SQLã®ã‚«ãƒ©ãƒ åž‹"
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr "デフォルトã®ã‚«ãƒ©ãƒ 型をオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã¾ã™( <literal><column></literal> è¦ç´ ã®å±žæ€§ã®ã¿)"
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr "default"
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr "SQLå¼"
+
+#: index.docbook:225
+msgid "default"
+msgstr "カラムã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã‚’指定ã—ã¾ã™"
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr "check"
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr "SQLå¼"
+
+#: index.docbook:232
+msgid "check"
+msgstr "カラムã‹ãƒ†ãƒ¼ãƒ–ルã«SQLã®ãƒã‚§ãƒƒã‚¯åˆ¶ç´„を作æˆã—ã¾ã™"
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">
+\n"
+ " <comment>Current customers only</comment>
+\n"
+ " ...
+\n"
+ "</class>]]>"
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr ""
+ "<![CDATA[<property name=\"balance\">
+\n"
+ " <column name=\"bal\">
+\n"
+ " <comment>Balance in USD</comment>
+\n"
+ " </column>
+\n"
+ "</property>]]>"
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr "ã“ã‚Œã«ã‚ˆã‚Šã€ç”Ÿæˆã—ãŸDDLã« <literal>comment on table</literal> ã‚„ <literal>comment on column</literal> æ–‡ãŒæ›¸ã‹ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr "ツールã®å®Ÿè¡Œ"
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr "<literal>SchemaExport</literal> ã¯æ¨™æº–出力ã«å¯¾ã—ã¦DDLスクリプトを書ã出ã—ã€DDL文を実行ã—ãŸã‚Šã‚‚ã—ã¾ã™ã€‚"
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr "<literal>java -cp </literal> <emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "<literal>SchemaExport</literal> Command Line Options <literal>SchemaExport</literal> ã®ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ã‚ªãƒ—ション"
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "オプション"
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr "--quiet"
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr "スクリプトを標準出力ã«å‡ºåŠ›ã—ã¾ã›ã‚“"
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr "--drop"
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr "テーブルã®å‰Šé™¤ã ã‘ã‚’è¡Œã„ã¾ã™"
+
+#: index.docbook:289
+msgid "--drop"
+msgstr "--create"
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr "テーブルã®ç”Ÿæˆã®ã¿ã‚’è¡Œã„ã¾ã™ã€‚"
+
+#: index.docbook:293
+msgid "--create"
+msgstr "--text"
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr "データベースã«ã‚¨ã‚¯ã‚¹ãƒãƒ¼ãƒˆã—ã¾ã›ã‚“"
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr "--output=my_schema.ddl"
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr "DDLスクリプトをファイルã«å‡ºåŠ›ã—ã¾ã™"
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr "--naming=eg.MyNamingStrategy"
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr "<literal>NamingStrategy</literal> ã‚’é¸æŠžã—ã¾ã™"
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr "--config=hibernate.cfg.xml"
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr "XMLファイルã‹ã‚‰Hibernateã®å®šç¾©æƒ…å ±ã‚’èªã¿è¾¼ã¿ã¾ã™"
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr "ファイルã‹ã‚‰ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒ—ãƒãƒ‘ティをèªã¿è¾¼ã¿ã¾ã™"
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr "--format"
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr "スクリプト内ã«ç”Ÿæˆã™ã‚‹SQLã‚’èªã¿ã‚„ã™ã„よã†ã«ãƒ•ã‚©ãƒ¼ãƒžãƒƒãƒˆã—ã¾ã™"
+
+#: index.docbook:317
+msgid "--format"
+msgstr "--delimiter=x"
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr "スクリプトã®è¡ŒåŒºåˆ‡ã‚Šæ–‡å—ã‚’è¨å®šã—ã¾ã™"
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr "アプリケーション㫠<literal>SchemaExport</literal> を組ã¿è¾¼ã‚€ã“ã¨ã‚‚ã§ãã¾ã™ï¼š"
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;
+\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr "プãƒãƒ‘ティ"
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr "次ã®ã‚ˆã†ã«ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ãƒ—ãƒãƒ‘ティを指定ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:337
+msgid "Properties"
+msgstr "<literal>-D</literal> <emphasis><property></emphasis> を使ã£ã¦ã€ã‚·ã‚¹ãƒ†ãƒ プãƒãƒ‘ティã¨ã—ã¦"
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr "<literal>hibernate.properties</literal> ファイル内ã§"
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "<literal>--properties</literal> を使ã£ã¦æŒ‡å®šã—ãŸãƒ—ãƒãƒ‘ティファイル内ã§"
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr "å¿…è¦ãªãƒ—ãƒãƒ‘ティã¯ä»¥ä¸‹ã®ã‚‚ã®ã§ã™ï¼š"
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr "SchemaExportコãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ãƒãƒ‘ティ"
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr "プãƒãƒ‘ティå"
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr "jdbcã®url"
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr "データベースã®ãƒ¦ãƒ¼ã‚¶"
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:381
+msgid "database user"
+msgstr "ユーザパスワード"
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr "hibernate.dialect"
+
+#: index.docbook:385
+msgid "user password"
+msgstr "データベース方言"
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr "Antを使用ã™ã‚‹"
+
+#: index.docbook:389
+msgid "dialect"
+msgstr "Antã®ãƒ“ルドスクリプトã‹ã‚‰ <literal>SchemaExport</literal> を呼ã³å‡ºã™ã“ã¨ãŒã§ãã¾ã™ã€‚:"
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr ""
+ "<![CDATA[<target name=\"schemaexport\">
+\n"
+ " <taskdef name=\"schemaexport\"
+\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"
+\n"
+ " classpathref=\"class.path\"/>
+\n"
+ "
+\n"
+ " <schemaexport
+\n"
+ " properties=\"hibernate.properties\"
+\n"
+ " quiet=\"no\"
+\n"
+ " text=\"no\"
+\n"
+ " drop=\"no\"
+\n"
+ " delimiter=\";\"
+\n"
+ " output=\"schema-export.sql\">
+\n"
+ " <fileset dir=\"src\">
+\n"
+ " <include name=\"**/*.hbm.xml\"/>
+\n"
+ " </fileset>
+\n"
+ " </schemaexport>
+\n"
+ "</target>]]>"
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr "インクリメンタルãªã‚¹ã‚ーマ更新"
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr "<literal>SchemaUpdate</literal> ツールã¯æ—¢å˜ã®ã‚¹ã‚ーマをインクリメンタルã«æ›´æ–°ã—ã¾ã™ã€‚ <literal>SchemaUpdate</literal> ã¯JDBCã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿APIã«å¼·ãä¾å˜ã—ã¾ã™ã€‚ ãã®ãŸã‚ã€ã™ã¹ã¦ã®JDBCドライãƒã§ã†ã¾ãã„ãã¨ã¯é™ã‚‰ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr "<literal>java -cp </literal> <emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr "<literal>SchemaUpdate</literal> ã®ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ï½¥ã‚ªãƒ—ション"
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "オプション"
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr "<literal>NamingStrategy</literal> ã‚’é¸æŠžã—ã¾ã™ã€‚"
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;
+\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr "インクリメンタルãªã‚¹ã‚ーマ更新ã«å¯¾ã™ã‚‹Antã®ä½¿ç”¨"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr "Antスクリプトã‹ã‚‰ <literal>SchemaUpdate</literal> を呼ã³å‡ºã™ã“ã¨ãŒã§ãã¾ã™ï¼š"
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr ""
+ "<![CDATA[<target name=\"schemaupdate\">
+\n"
+ " <taskdef name=\"schemaupdate\"
+\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"
+\n"
+ " classpathref=\"class.path\"/>
+\n"
+ "
+\n"
+ " <schemaupdate
+\n"
+ " properties=\"hibernate.properties\"
+\n"
+ " quiet=\"no\">
+\n"
+ " <fileset dir=\"src\">
+\n"
+ " <include name=\"**/*.hbm.xml\"/>
+\n"
+ " </fileset>
+\n"
+ " </schemaupdate>
+\n"
+ "</target>]]>"
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr "Schema validation"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr "<literal>SchemaValidator</literal> ツールã¯ã€æ—¢å˜ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã¨ä½œæˆã—ãŸãƒžãƒƒãƒ”ングドã‚ュメントãŒ\"一致ã™ã‚‹\"ã“ã¨ã‚’検証ã—ã¾ã™ã€‚ <literal>SchemaValidator</literal> ã¯JDBCã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿APIã«å¼·ãä¾å˜ã™ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。ãã®ãŸã‚ã€ã™ã¹ã¦ã®JDBCドライãƒãƒ¼ã§ä½œå‹•ã™ã‚‹ã‚‚ã®ã§ã¯ã‚ã‚Šã¾ã›ã‚“。ã“ã®ãƒ„ールã¯ãƒ†ã‚¹ãƒˆæ™‚ã«éžå¸¸ã«æœ‰ç”¨ã§ã™ã€‚"
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr "<literal>java -cp </literal> <emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr "<literal>SchemaValidator</literal> ã®ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ãƒ»ã‚ªãƒ—ション"
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "オプション"
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr "<entry>説明</entry>"
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr "スã‚ーマã®ãƒãƒªãƒ‡ãƒ¼ã‚·ãƒ§ãƒ³ã«Antを使用ã—ã¾ã™"
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr "Antスクリプトã‹ã‚‰ <literal>SchemaValidator</literal> を呼ã³å‡ºã›ã¾ã™:"
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr ""
+ "<![CDATA[<target name=\"schemavalidate\">
+\n"
+ " <taskdef name=\"schemavalidator\"
+\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"
+\n"
+ " classpathref=\"class.path\"/>
+\n"
+ "
+\n"
+ " <schemavalidator
+\n"
+ " properties=\"hibernate.properties\">
+\n"
+ " <fileset dir=\"src\">
+\n"
+ " <include name=\"**/*.hbm.xml\"/>
+\n"
+ " </fileset>
+\n"
+ " </schemavalidator>
+\n"
+ "</target>]]>"
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,794 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr "トランザクションã¨ä¸¦è¡Œæ€§"
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "Hibernateã¨åŒæ™‚実行制御ã«ã¤ã„ã¦æœ€ã‚‚é‡è¦ãªç‚¹ã¯ã€å®¹æ˜“ã«ç†è§£ã§ãã‚‹ã“ã¨ã§ã™ã€‚ Hibernateã¯æ–°ãŸãªãƒãƒƒã‚¯ã®æŒ¯ã‚‹èˆžã„ã‚’è¿½åŠ ã—ã¦ãŠã‚‰ãšã€ç›´æŽ¥JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã¨JTAリソースを使用ã—ã¾ã™ã€‚ JDBCã€ANSIã€ãŠã‚ˆã³ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ç®¡ç†ã‚·ã‚¹ãƒ†ãƒ （DBMS）ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³åˆ†é›¢ã®ä»•æ§˜ã‚’ å°‘ã—時間をã‹ã‘ã¦å‹‰å¼·ã™ã‚‹ã“ã¨ã‚’å¼·ã推奨ã—ã¾ã™ã€‚"
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr "Hibernateã¯ãƒ¡ãƒ¢ãƒªå†…ã®ã‚ªãƒ–ジェクトをãƒãƒƒã‚¯ã—ã¾ã›ã‚“。 アプリケーションã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®åˆ†é›¢ãƒ¬ãƒ™ãƒ«ã§ 定義ã—ãŸæŒ¯ã‚‹èˆžã„を期待ã§ãã¾ã™ã€‚ トランザクションスコープã®ã‚ャッシュã§ã‚‚ã‚ã‚‹ <literal>Session</literal> ã®ãŠé™°ã§ã€ è˜åˆ¥åやクエリã«ã‚ˆã‚Šæ¤œç´¢ã—ãŸã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¯ãƒªãƒ”ータブルリードã«ãªã‚Šã¾ã™ （スカラー値を返ã™ã‚ˆã†ãªãƒ¬ãƒãƒ¼ãƒˆã‚¯ã‚¨ãƒªã¯é•ã„ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã«ã‚ˆã‚‹è‡ªå‹•çš„ãªæ¥½è¦³çš„åŒæ™‚実行制御ã«åŠ ãˆã¦ã€ <literal>SELECT FOR UPDATE</literal> 文を使用ã—ã¦ã€ 行を悲観的ãƒãƒƒã‚¯ã™ã‚‹ãŸã‚ã®ï¼ˆãƒžã‚¤ãƒŠãƒ¼ãªï¼‰APIã‚‚æä¾›ã—ã¾ã™ã€‚ 楽観的åŒæ™‚実行制御ã¨ã“ã®APIã«ã¤ã„ã¦ã¯ã€ã“ã®ç« ã®å¾Œã®ã»ã†ã§è°è«–ã—ã¾ã™ã€‚"
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "データベーストランザクションや長ã„対話（conversationã€ãƒãƒ³ã‚°ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ï¼‰ã ã‘ã§ãªã〠<literal>Configuration</literal>ã€<literal>SessionFactory</literal>ã€ãŠã‚ˆã³ <literal>Session</literal> ã¨ã„ã†ç²’度ã§HibernateãŒè¡Œã†åŒæ™‚実行制御ã®è°è«–を始ã‚ã¾ã™ã€‚"
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr "sessionスコープã¨transactionスコープ"
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "<literal>SessionFactory</literal> ã¯ç”Ÿæˆã™ã‚‹ã“ã¨ãŒé«˜ä¾¡ã§ã€ スレッドセーフãªã‚ªãƒ–ジェクトã§ã™ã€‚ よã£ã¦ã€ã‚¢ãƒ—リケーションã®ã™ã¹ã¦ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã§å…±æœ‰ã™ã¹ãã§ã™ã€‚ 通常ã€ã‚¢ãƒ—リケーションã®èµ·å‹•æ™‚ã«ã€ <literal>Configuration</literal> インスタンスã‹ã‚‰ï¼‘度ã ã‘生æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr "<literal>Session</literal> ã¯é«˜ä¾¡ã§ã¯ãªãã€ã‚¹ãƒ¬ãƒƒãƒ‰ã‚»ãƒ¼ãƒ•ãªã‚ªãƒ–ジェクトã§ã‚‚ã‚ã‚Šã¾ã›ã‚“。 よã£ã¦ã€ï¼‘ã¤ã®è¦æ±‚や１ã¤ã®å¯¾è©±ã€ï¼‘ã¤ã®ä½œæ¥å˜ä½ï¼ˆunit of work）ã«å¯¾ã—ã¦ï¼‘度ã ã‘使ã„〠ãã®å¾Œã§æ¨ã¦ã‚‹ã¹ãã§ã™ã€‚ <literal>Session</literal> ã¯å¿…è¦ã«ãªã‚‹ã¾ã§ã€ JDBC <literal>Connection</literal>（もã—ã㯠<literal>DataSource</literal>）をç²å¾—ã—ã¾ã›ã‚“。 ゆãˆã«ã€å®Ÿéš›ã«ä½¿ç”¨ã™ã‚‹ã¨ãã¾ã§ãƒªã‚½ãƒ¼ã‚¹ã‚’消費ã—ã¾ã›ã‚“。"
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr "ã“ã®çŠ¶æ³ã‚’完了ã•ã›ã‚‹ãŸã‚ã«ã€ データベーストランザクションã«ã¤ã„ã¦ã‚‚考ãˆãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 データベース内ã®ãƒãƒƒã‚¯ã®ç«¶åˆã‚’å°‘ãªãã™ã‚‹ãŸã‚ã«ã€ データベーストランザクションã¯å¯èƒ½ãªé™ã‚ŠçŸãã™ã‚‹ã¹ãã§ã™ã€‚ é•·ã„データベーストランザクションã¯ã€ã‚¢ãƒ—リケーションã®é«˜ã„並列実行性を阻害ã—ã¾ã™ã€‚ ゆãˆã«ã€ãƒ¦ãƒ¼ã‚¶ãƒ¼ãŒè€ƒãˆã¦ã„る間（作æ¥å˜ä½ãŒå®Œäº†ã™ã‚‹ã¾ã§ï¼‰ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ é–‹ã„ãŸã¾ã¾ã«ã™ã‚‹ã®ã¯ã€ãŸã„ã¦ã„ã®å ´åˆã‚ˆã„è¨è¨ˆã¨ã¯ã„ãˆã¾ã›ã‚“。"
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr "作æ¥å˜ä½ã¨ã„ã†ã‚¹ã‚³ãƒ¼ãƒ—ã¨ã¯ä½•ã§ã—ょã†ã‹ï¼Ÿ １ã¤ã®Hibernate <literal>Session</literal> ã¯ã€ ã„ãã¤ã‹ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ã¾ãŸãŒã‚‹ã“ã¨ãŒã§ãã‚‹ã§ã—ょã†ã‹ï¼Ÿ ã¾ãŸã¯ã€ã‚¹ã‚³ãƒ¼ãƒ—ã¨ä¸€å¯¾ä¸€ã®é–¢ä¿‚ã§ã—ょã†ã‹ï¼Ÿ ã„㤠<literal>Session</literal> ã‚’é–‹ãã€é–‰ã˜ã‚‹ã¹ãã§ã—ょã†ã‹ï¼Ÿ ãã—ã¦ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’ã©ã®ã‚ˆã†ã«åˆ†ã‘ã‚‹ã®ã§ã—ょã†ã‹ï¼Ÿ"
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr "作æ¥å˜ä½ï¼ˆUnit of work）"
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr "１ã¤ç›®ã¯ã€<emphasis>session-per-operation</emphasis> アンãƒãƒ‘ターンを使ã£ã¦ã¯ã„ã‘ã¾ã›ã‚“。 ã™ãªã‚ã¡ã€ï¼‘ã¤ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã®ä¸ã§ã€å˜ç´”ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å‘¼ã³å‡ºã—ã®ãŸã³ã« <literal>Session</literal> ã‚’é–‹ã„ã¦ã€é–‰ã˜ã¦ã¯ã„ã‘ã¾ã›ã‚“ï¼ ã‚‚ã¡ã‚ã‚“ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«ã¤ã„ã¦ã‚‚åŒæ§˜ã§ã™ã€‚ アプリケーションä¸ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å‘¼ã³å‡ºã—ã¯ã€ 計画ã•ã‚ŒãŸã‚·ãƒ¼ã‚±ãƒ³ã‚¹ï¼ˆplanned sequence）を使ã„〠アトミックãªä½œæ¥å˜ä½ã«åˆ†é¡žã•ã‚Œã¾ã™ã€‚ （１ã¤ã®SQLæ–‡ã”ã¨ã«ã‚³ãƒŸãƒƒãƒˆã™ã‚‹è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆãŒã€ 使ã‚ã‚Œãªã„ã¨ã„ã†æ„味ã§ã‚‚ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 自動コミットã¯ã€SQLコンソールã§ã‚¢ãƒ‰ãƒ›ãƒƒã‚¯ãªä½œæ¥ã‚’ã™ã‚‹éš›ã«ä½¿ã†ã‚‚ã®ã§ã™ã€‚ Hibernateã¯ç›´ã¡ã«è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆãƒ¢ãƒ¼ãƒ‰ã‚’無効ã«ã—ã¾ã™ã€‚ ã‚‚ã—ãã¯ã€ã‚¢ãƒ—リケーションサーãƒãƒ¼ãŒç„¡åŠ¹åŒ–ã™ã‚‹ã“ã¨ã‚’期待ã—ã¾ã!
™ã€‚） データベーストランザクションã¯ã‚ªãƒ—ションã§ã¯ã‚ã‚Šã¾ã›ã‚“。 データベースã¨ã®ã™ã¹ã¦ã®é€šä¿¡ã¯ã€ãƒ‡ãƒ¼ã‚¿ã®èªã¿è¾¼ã¿ã§ã‚ã£ã¦ã‚‚ã€æ›¸ãè¾¼ã¿ã§ã‚ã£ã¦ã‚‚〠トランザクションã®ä¸ã§è¡Œã‚ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 説明ã™ã‚‹ã¨ã€ãƒ‡ãƒ¼ã‚¿èªã¿è¾¼ã¿ã«å¯¾ã—ã¦ã€è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆã¯é¿ã‘ã‚‹ã¹ãã§ã™ã€‚ ãªãœãªã‚‰ã€å¤šæ•°ã®å°ã•ãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã¯ã€æ˜Žç¢ºã«å®šç¾©ã•ã‚ŒãŸï¼‘ã¤ã®ä½œæ¥å˜ä½ã¨æ¯”ã¹ã¦ã€ パフォーマンスãŒã‚ˆããªã‚‹ã“ã¨ã¯ã‚ã‚Šã¾ã›ã‚“。 後者ã¯ä¿å®ˆæ€§ã‚„拡張性もよりã™ãã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "マルãƒãƒ¦ãƒ¼ã‚¶ãƒ¼ã®ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆï¼ã‚µãƒ¼ãƒãƒ¼ã‚¢ãƒ—リケーションã®ä¸ã§ã€ 最もよã使ã‚れるパターンã¯ã€<emphasis>session-per-request</emphasis> ã§ã™ã€‚ ã“ã®ãƒ¢ãƒ‡ãƒ«ã®ä¸ã§ã¯ã€ クライアントã‹ã‚‰ï¼ˆHibernate永続化層ãŒå‹•ä½œã™ã‚‹ï¼‰ã‚µãƒ¼ãƒãƒ¼ã¸ãƒªã‚¯ã‚¨ã‚¹ãƒˆãŒé€ã‚‰ã‚Œã€ æ–°ã—ã„Hibernate <literal>Session</literal> ãŒé–‹ã‹ã‚Œã¾ã™ã€‚ ãã—ã¦ã€ã“ã®ä½œæ¥å˜ä½ã®ä¸ã§ã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å‡¦ç†ãŒå®Ÿè¡Œã•ã‚Œã¾ã™ã€‚ 作æ¥ãŒå®Œäº†ã—ãŸï¼ˆãã—ã¦ã€ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆã¸ã®ãƒ¬ã‚¹ãƒãƒ³ã‚¹ãŒæº–å‚™ã§ããŸï¼‰æ™‚点ã§ã€ session をフラッシュã—ã€é–‰ã˜ã¾ã™ã€‚ クライアントã®è¦æ±‚を処ç†ã™ã‚‹ãŸã‚ã«ã€ï¼‘ã¤ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’使用ã™ã‚‹ã§ã—ょã†ã€‚ <literal>Session</literal> ã‚’é–‹ãã€é–‰ã˜ã‚‹éš›ã«ã€ データベーストランザクションを開始ã—ã€ã‚³ãƒŸãƒƒãƒˆã—ã¾ã™ã€‚ 二ã¤ã®é–¢ä¿‚ã¯ä¸€å¯¾ä¸€ã§ã™ã€‚ ã“ã®ãƒ¢ãƒ‡!
ルã¯å¤šãã®ã‚¢ãƒ—リケーションã«å®Œå…¨ã«é©åˆã—ã¾ã™ã€‚"
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr "以é™ã®å®Ÿè£…ã«ãƒãƒ£ãƒ¬ãƒ³ã‚¸ã—ã¦ãã ã•ã„。 <literal>Session</literal> ã‚’æŒã¡ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’æ£ç¢ºã«é–‹å§‹ã—ã€çµ‚ã‚らã›ã‚‹ã ã‘ã§ãªã〠データアクセスæ“作も得やã™ãã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ リクエストãŒã‚µãƒ¼ãƒãƒ¼ã«ãƒ’ットã—ãŸéš›ã¨ã€ãƒ¬ã‚¹ãƒãƒ³ã‚¹ã‚’é€ä¿¡ã™ã‚‹å‰ã«ã€å®Ÿè¡Œã•ã‚Œã‚‹interceptor （例ãˆã°ã€<literal>ServletFilter</literal>）を使ã£ã¦ã€ä½œæ¥å˜ä½ã®å¢ƒç•Œã‚’実装ã™ã‚‹ã®ãŒç†æƒ³çš„ã§ã™ã€‚ <literal>ThreadLocal</literal> 変数を使ã£ã¦ã€ リクエストを処ç†ã™ã‚‹ã‚¹ãƒ¬ãƒƒãƒ‰ã« <literal>Session</literal> ã‚’çµã³ã¤ã‘ã‚‹ã“ã¨ã‚’推奨ã—ã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚Šã€ã‚¹ãƒ¬ãƒƒãƒ‰å†…ã§å®Ÿè¡Œã•ã‚Œã‚‹ã™ã¹ã¦ã®ã‚³ãƒ¼ãƒ‰ã§ã€ （static変数ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã‚ˆã†ã«ï¼‰ç°¡å˜ã« <literal>Session</literal> ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãるよã†ã«ãªã‚Šã¾ã™ã€‚ é¸æŠžã—ãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã®æ©Ÿæ§‹æ¬¡ç¬¬ã§ã€<literal>ThreadL!
ocal</literal> 変数ã®ä¸ã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚³ãƒ³ãƒ†ã‚ストをä¿æŒã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã“ã®å®Ÿè£…パターンã¯ã€<emphasis>ThreadLocal Session</emphasis> ãŠã‚ˆã³ <emphasis>Open Session in View</emphasis> ã¨ã„ã†åå‰ã§çŸ¥ã‚‰ã‚Œã¦ã„ã¾ã™ã€‚ 本ドã‚ュメントã§å…ˆã«è¦‹ã›ãŸ <literal>HibernateUtil</literal> ヘルパークラスを拡張ã™ã‚‹ã“ã¨ã§ã€ ã“ã®ãƒ‘ターンを容易ã«å®Ÿè£…ã§ãã¾ã™ã€‚ ã‚‚ã¡ã‚ã‚“ã€interceptor を実装ã™ã‚‹æ–¹æ³•ã‚’見ã¤ã‘ã€ç’°å¢ƒã‚’セットアップã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ Hibernateã®Webサイトã«ã‚ã‚‹tipsã¨ä¾‹ã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "以é™ã®å®Ÿè£…ã«ãƒãƒ£ãƒ¬ãƒ³ã‚¸ã—ã¦ãã ã•ã„。 Hibernateã¯å˜ç´”ãªã“ã®ãƒ‘ターンã®ãŸã‚ã«ã€äºˆã‚組ã¿è¾¼ã¾ã‚ŒãŸ 「current sessionã€ã®ç®¡ç†ã‚’æä¾›ã—ã¾ã™ã€‚ サーãƒãƒ¼ãƒªã‚¯ã‚¨ã‚¹ãƒˆã‚’処ç†ã™ã‚‹éš›ã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’開始ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ãã—ã¦ã€ãƒ¬ã‚¹ãƒãƒ³ã‚¹ã‚’クライアントã«é€ä¿¡ã™ã‚‹å‰ã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’終ã‚らã›ã¾ã™ã€‚ 好ããªæ–¹æ³•ã§å®Ÿç¾ã§ãã¾ã™ã€‚一般的ãªè§£æ±ºç–㯠<literal>ServletFilter</literal> ã‚„ サービスメソッドをãƒã‚¤ãƒ³ãƒˆã‚«ãƒƒãƒˆã—ã¦AOPインターセプター〠proxy/interception コンテナã§ã™ã€‚ EJBコンテナã¯EJBセッションビーンをトランザクション境界ã¨ã—㦠アスペクトをクãƒã‚¹ã‚«ãƒƒãƒˆã™ã‚‹å®Ÿè£…ã®æ¨™æº–çš„ãªæ–¹æ³•ã§ã™ï¼ˆCMTã«ã‚ˆã‚‹å®£è¨€çš„）。 プãƒã‚°ãƒ©ãƒ ã«ã‚ˆã‚‹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’使ã†ã¨æ±ºã‚ãŸå ´åˆã€ ç°¡å˜ã«ä½¿ã†ãŸã‚ã€äº’æ›æ€§ã®ã‚るコードã«ã!
™ã‚‹ãŸã‚ã«ã€ ã“ã®ç« ã®å¾Œã®ã»ã†ã«ã‚ã‚‹Hibernate <literal>Transaction</literal> APIã®ã»ã†ãŒã‚ˆã„ã§ã™ã€‚"
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "アプリケーションã®ã‚³ãƒ¼ãƒ‰ã¯ã€å¿…è¦ãªã¨ãã«ã©ã“ã§ã‚‚ã€ä½•å›žã§ã‚‚〠å˜ã« <literal>sessionFactory.getCurrentSession()</literal> を呼ã³å‡ºã™ã ã‘㧠「ç¾åœ¨ã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã€ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã™ã€‚ ç¾åœ¨ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã¸ã® <literal>セッション</literal> を常ã«å–å¾—ã—ã¾ã™ã€‚ リソース・ãƒãƒ¼ã‚«ãƒ«ãªç’°å¢ƒã€ã‚‚ã—ãã¯JTA環境を構æˆã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“ （<xref linkend=\"architecture-current-session\"/> ã‚’å‚ç…§ã—ã¦ãã ã•ã„）。"
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr "ã¨ãã©ãã€ã€Œãƒ“ューをæç”»ã™ã‚‹ã€ã¾ã§ <literal>セッション</literal> ã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚¹ã‚³ãƒ¼ãƒ—ã‚’æ‹¡å¼µã™ã‚‹ã¨ä¾¿åˆ©ãªã“ã¨ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ã€è¦æ±‚ã®å‡¦ç†ã¨æç”»ã®ãƒ•ã‚§ãƒ¼ã‚ºã‚’分ã‘ã¦ã„ã‚‹ サーブレットアプリケーションã«ãŠã„ã¦ç‰¹ã«å½¹ç«‹ã¡ã¾ã™ã€‚ 独自ã®ã‚¤ãƒ³ã‚¿ãƒ¼ã‚»ãƒ—タを実装ã™ã‚Œã°ã€ ビューをæç”»ã™ã‚‹ã¾ã§ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’æ‹¡å¼µã™ã‚‹ã®ã¯ç°¡å˜ã§ã™ã€‚ ã—ã‹ã—ã€ã‚³ãƒ³ãƒ†ãƒŠç®¡ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®EJBã«é ¼ã‚‹å ´åˆã¯ã€ç°¡å˜ã«ã¯ã§ãã¾ã›ã‚“。 ãªãœãªã‚‰ã€ãƒ“ューã®æ画を開始ã™ã‚‹å‰ã«ã€EJBã®ãƒ¡ã‚½ãƒƒãƒ‰ãŒãƒªã‚¿ãƒ¼ãƒ³ã—ãŸéš›ã«ã€ トランザクションãŒå®Œäº†ã™ã‚‹ãŸã‚ã§ã™ã€‚ ã“ã® <emphasis>Open Session in View</emphasis> パターンã«é–¢é€£ã™ã‚‹ãƒ’ントã¨ä¾‹ã«ã¤ã„ã¦ã¯ã€ Hibernateã®Webサイトやフォーラムをå‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "é•·ã„対話"
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "session-per-requestパターンã¯ã€ä½œæ¥å˜ä½ã‚’è¨è¨ˆã™ã‚‹éš›ã«å½¹ç«‹ã¤è€ƒãˆã¨ã„ã†ã ã‘ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 多ãã®ãƒ“ジãƒã‚¹ãƒ—ãƒã‚»ã‚¹ã¯ã€ãƒ¦ãƒ¼ã‚¶ãƒ¼ã¨ã®ä¸€é€£ã®ç›¸äº’作用全体をè¦æ±‚ã—ã¾ã™ã€‚ ãã®ç›¸äº’作用ã«ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¢ã‚¯ã‚»ã‚¹ãŒå«ã¾ã‚Œã¾ã™ã€‚ Webã¨ã‚¨ãƒ³ã‚¿ãƒ¼ãƒ—ライズアプリケーションã§ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒ ユーザã¨ã®ç›¸äº’作用ã«ã¾ã§æ¸¡ã‚‹ã“ã¨ã¯è¨±ã•ã‚Œã¾ã›ã‚“。 次ã®ä¾‹ã‚’よã考ãˆã¦ã¿ã¦ãã ã•ã„。"
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr "ダイアãƒã‚°ã®æœ€åˆã®ç”»é¢ãŒé–‹ãã€å€‹ã€…ã® <literal>Session</literal> ã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ä¸ã§ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸãƒ‡ãƒ¼ã‚¿ã‚’ユーザーã«è¦‹ã›ã¾ã™ã€‚ ユーザーã¯ã‚ªãƒ–ジェクトを自由ã«ä¿®æ£ã§ãã¾ã™ã€‚"
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr "5分後ã«ãƒ¦ãƒ¼ã‚¶ãƒ¼ã¯ã€ŒSaveã€ã‚’クリックã—ã€ä¿®æ£ãŒæ°¸ç¶šåŒ–ã•ã‚Œã‚‹ã®ã‚’期待ã—ã¾ã™ã€‚ ã¾ãŸã€ã“ã®æƒ…å ±ã‚’ç·¨é›†ã—ãŸã®ã¯è‡ªåˆ†ï¼‘人ã ã‘ã§ã€ ä¿®æ£ã®ã‚³ãƒ³ãƒ•ãƒªã‚¯ãƒˆã¯ç™ºç”Ÿã—ãªã„ã¨æœŸå¾…ã—ã¾ã™ã€‚"
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "ã“ã®ä½œæ¥å˜ä½ã‚’（ユーザーã®è¦–点ã§ï¼‰é•·æœŸã® <emphasis>対話</emphasis> （もã—ãã¯ã€<emphasis>アプリケーショントランザクション</emphasis> ）ã¨å‘¼ã³ã¾ã™ã€‚ アプリケーションã«ã“れを実装ã™ã‚‹æ–¹æ³•ã¯ãŸãã•ã‚“ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr "最åˆã«æ€ã„ã¤ã実装ã¯ã€ãƒ¦ãƒ¼ã‚¶ãƒ¼ãŒè€ƒãˆã¦ã„ã‚‹é–“ã€<literal>Session</literal> ã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’é–‹ã„ãŸã¾ã¾ã«ã—ã¦ãŠãã“ã¨ã§ã™ã€‚ åŒæ™‚ã«ä¿®æ£ã•ã‚Œãšã€åˆ†é›¢ã¨åŽŸå性ãŒä¿è¨¼ã•ã‚Œã‚‹ã‚ˆã†ã«ã€ データベース内ã®ãƒãƒƒã‚¯ã¯ä¿æŒã—ãŸã¾ã¾ã«ã—ã¾ã™ã€‚ ã‚‚ã¡ã‚ã‚“ã€ã“ã‚Œã¯ã‚¢ãƒ³ãƒãƒ‘ターンã§ã™ã€‚ ãªãœãªã‚‰ã€ãƒãƒƒã‚¯ã®ç«¶åˆãŒç™ºç”Ÿã™ã‚‹ã¨ã€ アプリケーションãŒåŒæ™‚ユーザー数ã«å¿œã˜ã¦ã‚¹ã‚±ãƒ¼ãƒ«ã‚¢ãƒƒãƒ—ã§ããªããªã‚‹ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr "明らã‹ã«ã€å¯¾è©±ã‚’実装ã™ã‚‹ãŸã‚ã«ã¯ã€ ã„ãã¤ã‹ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’使用ã™ã‚‹ã¹ãã§ã™ã€‚ ã“ã®å ´åˆã€ãƒ“ジãƒã‚¹ãƒ—ãƒã‚»ã‚¹ã®åˆ†é›¢ã‚’ç¶æŒã™ã‚‹ã“ã¨ã¯ã€ アプリケーション層ã®è²¬å‹™ã®ï¼‘ã¤ã«ãªã‚Šã¾ã™ã€‚ １ã¤ã®å¯¾è©±ã¯ã€ 通常ã„ãã¤ã‹ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«åŠã³ã¾ã™ã€‚ データベーストランザクションã®ï¼‘ã¤ã®ã¿ï¼ˆæœ€å¾Œã®ï¼‘ã¤ï¼‰ãŒæ›´æ–°ã—ãŸãƒ‡ãƒ¼ã‚¿ã‚’ä¿å˜ã—〠他ã¯ãƒ‡ãƒ¼ã‚¿ã‚’èªã‚€ã ã‘ã§ã‚ã‚Œã°ã€ãã‚Œã¯ã‚¢ãƒˆãƒŸãƒƒã‚¯ã§ã™ （例ãˆã°ã€ã„ãã¤ã‹ã®è¦æ±‚ï¼å¿œç”ã‚’ç¹°ã‚Šè¿”ã™ã‚¦ã‚£ã‚¶ãƒ¼ãƒ‰å½¢å¼ã®ãƒ€ã‚¤ã‚¢ãƒã‚°ï¼‰ã€‚ ã“ã‚Œã¯èžãよりã€å®Ÿè£…ã—ãŸã»ã†ãŒç°¡å˜ã§ã™ã€‚ Hibernateã®æ©Ÿèƒ½ã‚’使ã†ã®ã§ã‚ã‚Œã°ã€ç‰¹ã«ç°¡å˜ã§ã™ã€‚"
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "<emphasis>自動ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°</emphasis> - Hibernateã¯è‡ªå‹•çš„ã«æ¥½è¦³çš„åŒæ™‚実行制御ãŒã§ãã¾ã™ã€‚ ユーザーãŒè€ƒãˆã¦ã„ã‚‹é–“ã«åŒæ™‚ã«ä¿®æ£ãŒãŠããŸå ´åˆã€è‡ªå‹•çš„ã«æ¤œå‡ºã§ãã¾ã™ã€‚ 通常ã€å¯¾è©±ã®çµ‚了時ã«ãƒã‚§ãƒƒã‚¯ã™ã‚‹ã ã‘ã§ã™ã€‚"
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr "<emphasis>分離（Detached）オブジェクト</emphasis> - ã™ã§ã«è°è«–ã—㟠<emphasis>session-per-request</emphasis> パターンを使ã†ã¨æ±ºå®šã—ãŸå ´åˆã€ ãƒãƒ¼ãƒ‰ã•ã‚ŒãŸã™ã¹ã¦ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ãƒ¦ãƒ¼ã‚¶ãŒè€ƒãˆã¦ã„ã‚‹é–“ã¯ã€ セッションã‹ã‚‰åˆ†é›¢ã•ã‚ŒãŸçŠ¶æ…‹ã«ãªã‚Šã¾ã™ã€‚ オブジェクトをセッションã«å†è¿½åŠ ã—ã€ä¿®æ£ã‚’永続化ã§ãã¾ã™ã€‚ ã“れを <emphasis>session-per-request-with-detached-objects</emphasis> パターンã¨å‘¼ã³ã¾ã™ã€‚ 自動ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã‚’使ã†ã“ã¨ã§ã€åŒæ™‚ã«è¡Œã‚れる修æ£ã‚’分離ã§ãã¾ã™ã€‚"
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr "<emphasis>拡張（もã—ãã¯ã€é•·ã„）セッション</emphasis> - Hibernateã® <literal>Session</literal> ã¯ã€ データベーストランザクションをコミットã—ãŸå¾Œã€ è£ã§çµã³ã¤ã„ã¦ã„ã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’切æ–ã§ãã¾ã™ã€‚ ãã—ã¦ã€ã‚¯ãƒ©ã‚¤ã‚¢ãƒ³ãƒˆã‹ã‚‰ã®æ–°ã—ã„è¦æ±‚ãŒç™ºç”Ÿã—ãŸéš›ã«ã€å†æŽ¥ç¶šã§ãã¾ã™ã€‚ ã“ã®ãƒ‘ターンã¯ã€<emphasis>session-per-conversation</emphasis> ã¨ã„ã†åã§çŸ¥ã‚‰ã‚Œã¦ãŠã‚Šã€ã‚ªãƒ–ジェクトをセッションã¸å†è¿½åŠ ã™ã‚‹ã“ã¨ã•ãˆä¸è¦ã«ã—ã¾ã™ã€‚ 自動ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã‚’使ã†ã“ã¨ã§ã€åŒæ™‚ã«è¡Œã‚れる修æ£ã‚’分離ã§ãã¾ã™ã€‚ 通常 <literal>Session</literal> を自動的ã«ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã•ã›ãšã€ 明示的ã«ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã—ã¾ã™ã€‚"
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr "<emphasis>session-per-request-with-detached-objects</emphasis> 㨠<emphasis>session-per-conversation</emphasis> ã®ï¼’ã¤ã¯ã€ 利点ã¨æ¬ 点をæŒã£ã¦ã„ã¾ã™ã€‚ ã“ã‚Œã«ã¤ã„ã¦ã¯ã€ã“ã®ç« ã®å¾Œã®ã»ã†ã§ã€æ¥½è¦³çš„åŒæ™‚実行制御ã®æ–‡è„ˆã®ä¸ã§è°è«–ã—ã¾ã™ã€‚"
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr "オブジェクトè˜åˆ¥åを考ãˆã‚‹"
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr "アプリケーションã¯ã€ï¼’ã¤ã®ç•°ãªã‚‹ <literal>Session</literal> ã‹ã‚‰ åŒã˜æ°¸ç¶šçŠ¶æ…‹ã«åŒæ™‚ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã™ã€‚ ã—ã‹ã—ã€ï¼’ã¤ã® <literal>Session</literal> インスタンス㌠永続性クラスã®ï¼‘ã¤ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’共有ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 ゆãˆã«ã€è˜åˆ¥åã«ã¯ï¼’ã¤ã®ç•°ãªã‚‹æ¦‚念ãŒã‚ã‚‹ã¨ã„ã†ã“ã¨ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr "データベースè˜åˆ¥å"
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr "foo.getId().equals( bar.getId() )"
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr "JVMè˜åˆ¥å"
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr "foo==bar"
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr "<emphasis>個々ã®</emphasis> <literal>Session</literal> ã«è¿½åŠ ã•ã‚ŒãŸã‚ªãƒ–ジェクトã«ã¨ã£ã¦ （ã™ãªã‚ã¡ã€ï¼‘ã¤ã® <literal>Session</literal> ã®ã‚¹ã‚³ãƒ¼ãƒ—ã®ä¸ã§ã¯ï¼‰ã€ï¼’ã¤ã®æ¦‚念ã¯åŒã˜ã§ã™ã€‚ データベースåŒä¸€æ€§ã¨JVMåŒä¸€æ€§ãŒä¸€è‡´ã™ã‚‹ã“ã¨ã‚’ã€HibernateãŒä¿è¨¼ã—ã¾ã™ã€‚ ã—ã‹ã—ã€ã‚¢ãƒ—リケーションãŒï¼’ã¤ã®ç•°ãªã‚‹ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‹ã‚‰ 「åŒã˜ã€ï¼ˆæ°¸ç¶šæ€§è˜åˆ¥åã®ï¼‰ãƒ“ジãƒã‚¹ã‚ªãƒ–ジェクトã«åŒæ™‚ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹é™ã‚Šã€ ï¼’ã¤ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯å®Ÿéš›ã«ï¼ˆJVMè˜åˆ¥åãŒï¼‰ã€Œç•°ãªã‚Šã€ã¾ã™ã€‚ 楽観的アプãƒãƒ¼ãƒã«ã‚ˆã£ã¦ã€ï¼ˆè‡ªå‹•ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã®ï¼‰ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ï¼ã‚³ãƒŸãƒƒãƒˆæ™‚㫠コンフリクトãŒè§£æ±ºã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã¯ã€Hibernateã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«åŒæ™‚実行ã«ã¤ã„ã¦ã®å¿ƒé…ãŒæ®‹ã‚Šã¾ã™ã€‚ 一方ã§ã€æœ€é«˜ã®ã‚¹ã‚±ãƒ¼ãƒ©ãƒ“リティãŒæä¾›ã•ã‚Œã¾ã™ã€‚ ãªãœãªã‚‰ã€ï¼‘スレッドã®ä½œæ¥å˜ä½ã®ä¸ã§ä¸€æ„性ãŒä¿è¨¼ã•ã‚Œã‚Œã°ã€ 高価ãªãƒãƒƒã‚¯ã‚„åŒæœŸåŒ–ãŒä¸è¦ã«ãªã‚‹ãŸã‚ã§ã™ã€‚ <literal>Session</literal> ã”ã¨ã«ï¼‘ã¤ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã‚’貼り付ã‘ã‚‹é™ã‚Šã€ アプリケーションã¯ãƒ“ジãƒã‚¹ã‚ªãƒ–ジェクトをsynchronizeã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 <literal>Session</literal> 内ã§ã¯ã€ã‚¢ãƒ—リケーションã¯ã‚ªãƒ–ジェクトを比較ã™ã‚‹ãŸã‚ã«ã€ <literal>==</literal> を安全ã«ä½¿ç”¨ã§ãã¾ã™ã€‚"
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr "ã‘ã‚Œã©ã‚‚ã€<literal>Session</literal> ã®å¤–㧠<literal>==</literal> を使ã†ã‚¢ãƒ—リケーションã¯ã€äºˆæœŸã—ãªã„çµæžœã«éé‡ã—ã¾ã™ã€‚ ã“ã‚Œã¯äºˆæœŸã—ãªã„å ´æ‰€ã§èµ·ã“ã‚Šãˆã¾ã™ã€‚ 例ãˆã°ã€ï¼’ã¤ã®åˆ†é›¢ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’åŒã˜ <literal>Set</literal> ã« putã—ãŸã¨ããªã©ã§ã™ã€‚ 両方ã¨ã‚‚åŒã˜ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹è˜åˆ¥åã‚’æŒã¡ã¾ã™ï¼ˆã™ãªã‚ã¡ã€åŒã˜è¡Œã‚’表ã—ã¾ã™ï¼‰ã€‚ ã—ã‹ã—ã€åˆ†é›¢çŠ¶æ…‹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®JVMè˜åˆ¥åã¯å½“然ä¿è¨¼ã•ã‚Œã¾ã›ã‚“。 開発者ã¯ã€æ°¸ç¶šæ€§ã‚¯ãƒ©ã‚¹ã® <literal>equals()</literal> 㨠<literal>hashCode()</literal> メソッドをオーãƒãƒ¼ãƒ©ã‚¤ãƒ‰ã—ã€ã‚ªãƒ–ジェクトç‰ä¾¡æ€§ã®æ¦‚念を実装ã™ã¹ãã§ã™ã€‚ è¦å‘ŠãŒï¼‘ã¤ã‚ã‚Šã¾ã™ã€‚ç‰ä¾¡æ€§ã®å®Ÿè£…ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹è˜åˆ¥åを使ã‚ãªã„ã§ãã ã•ã„。 ユニークãªï¼ˆæ™®é€šã¯ä¸å¤‰ã®ï¼‰å±žæ€§ã®çµ„ã¿åˆã‚ã›ã§ã‚るビジãƒã‚¹ã‚ーを使ã£ã¦ãã ã•ã„。 ã‚‚ã—ã€ä¸€æ™‚オ!
ブジェクトãŒæ°¸ç¶šåŒ–ã•ã‚ŒãŸå ´åˆã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹è˜åˆ¥åãŒå¤‰ã‚ã‚Šã¾ã™ã€‚ 一時オブジェクトを（通常分離インスタンスã¨å…±ã«ï¼‰ <literal>Set</literal> ã«ä¿æŒã™ã‚‹å ´åˆã€ãƒãƒƒã‚·ãƒ¥ã‚³ãƒ¼ãƒ‰ãŒå¤‰ã‚ã‚‹ã¨ã„ã†ã“ã¨ã¯ã€<literal>Set</literal> ã®å¥‘ç´„ã‚’ç ´ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ビジãƒã‚¹ã‚ーã®ãŸã‚ã®å±žæ€§ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ä¸»ã‚ーã»ã©å®‰å®šã™ã¹ãã§ã¯ãªã„ã§ã™ã€‚ オブジェクトãŒåŒã˜ <literal>Set</literal> ã®ä¸ã«ã„ã‚‹é–“ã ã‘ã€å®‰å®šã‚’ä¿è¨¼ã™ã¹ãã§ã™ã€‚ ã“ã®å•é¡Œã®ã‚ˆã‚Šå¾¹åº•çš„ãªè°è«–ã¯ã€Hibernateã®Webサイトをå‚ç…§ã—ã¦ãã ã•ã„。 ã¾ãŸã€ã“ã‚Œã¯Hibernateã®å•é¡Œã§ã¯ãªãã€å˜ã«Javaオブジェクトã®è˜åˆ¥åã‚„ç‰ä¾¡æ€§ã‚’ ã©ã®ã‚ˆã†ã«å®Ÿè£…ã™ã¹ãã‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr "一般的ãªå•é¡Œ"
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "<emphasis>session-per-user-session</emphasis> 㨠<emphasis>session-per-application</emphasis> アンãƒãƒ‘ターン ã¯ä½¿ã£ã¦ã¯ã„ã‘ã¾ã›ã‚“（もã¡ã‚ã‚“ã€ã¾ã‚Œã«ä¾‹å¤–ãŒã‚ã‚Šã¾ã™ï¼‰ã€‚ 注æ„：下記ã®å•é¡Œã®ã„ãã¤ã‹ã¯ã€æŽ¨å¥¨ã•ã‚Œã‚‹ãƒ‘ターンã¨ã—ã¦ã‚‚出ç¾ã—ã¾ã™ã€‚ è¨è¨ˆã‚’決定ã™ã‚‹å‰ã«ã€è£ã®æ„味をç†è§£ã™ã‚‹ã‚ˆã†ã«ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr "<literal>Session</literal> ã¯ã‚¹ãƒ¬ãƒƒãƒ‰ã‚»ãƒ¼ãƒ•ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 HTTPリクエストã€ã‚»ãƒƒã‚·ãƒ§ãƒ³Beanã€Swingワーカーã®ã‚ˆã†ã«ã€ åŒæ™‚実行ãŒå¯èƒ½ãªã‚‚ã®ãŒ <literal>Session</literal> インスタンスを共有ã™ã‚‹ã¨ã€ 競åˆçŠ¶æ…‹ã‚’引ãèµ·ã“ã—ã¾ã™ã€‚ （後ã§è°è«–ã™ã‚‹ï¼‰<literal>HttpSession</literal> ã®ä¸ã§ Hibernate <literal>Session</literal> ã‚’ä¿æŒã™ã‚‹å ´åˆã€ HttpSessionã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ã‚’åŒæœŸåŒ–ã™ã‚‹ã“ã¨ã‚’考慮ã™ã¹ãã§ã™ã€‚ ã•ã‚‚ãªã‘ã‚Œã°ã€ãƒ¦ãƒ¼ã‚¶ãƒ¼ãŒå分早ãリãƒãƒ¼ãƒ‰ã‚’クリックã™ã‚‹ã¨ã€ åŒæ™‚ã«èµ°ã‚‹ï¼’ã¤ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã®ä¸ã§ã€åŒã˜ <literal>Session</literal> ãŒä½¿ã‚ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr "HibernateãŒä¾‹å¤–を投ã’ãŸå ´åˆã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—〠直ã¡ã« <literal>Session</literal> ã‚’é–‰ã˜ã‚‹ã¹ãã§ã™ï¼ˆè©³ç´°ã‚’後ã§è°è«–ã—ã¾ã™ï¼‰ã€‚ <literal>Session</literal> ãŒã‚¢ãƒ—リケーションã«çµã³ä»˜ã‘られã¦ã„ã‚‹ã®ã§ã‚ã‚Œã°ã€ アプリケーションをåœæ¢ã™ã¹ãã§ã™ã€‚ データベーストランザクションをãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—ã¦ã‚‚ã€ãƒ“ジãƒã‚¹ã‚ªãƒ–ジェクト㯠トランザクションを開始ã—ãŸã¨ãã®çŠ¶æ…‹ã«æˆ»ã‚Šã¾ã›ã‚“。 ã“ã‚Œã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®çŠ¶æ…‹ã¨ãƒ“ジãƒã‚¹ã‚ªãƒ–ジェクトã¯åŒæœŸã—ã¦ã„ãªã„ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚ 通常ã“ã‚Œã¯å•é¡Œã«ãªã‚Šã¾ã›ã‚“。 ãªãœãªã‚‰ã€ä¾‹å¤–ã¯å›žå¾©ã§ããªã„ã‹ã‚‰ã§ã™ã€‚ ã¨ã«ã‹ããƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—ãŸå¾Œã«ã‚„ã‚Šç›´ã™ã¹ãã§ã™ã€‚"
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr "<literal>Session</literal> ã¯æ°¸ç¶šï¼ˆpersistent）状態ã®ã™ã¹ã¦ã®ã‚ªãƒ–ジェクトを ã‚ャッシュã—ã¾ã™ï¼ˆHibernateã¯ç›£è¦–ã—ã€ãƒ€ãƒ¼ãƒ†ã‚£çŠ¶æ…‹ã‹ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ï¼‰ã€‚ ã“ã‚Œã¯ã€é•·ã„間セッションを開ã„ãŸã¾ã¾ã«ã™ã‚‹ã‹ã€ éžå¸¸ã«å¤šãã®ãƒ‡ãƒ¼ã‚¿ã‚’ãƒãƒ¼ãƒ‰ã—続ã‘ã‚‹ã‹ã—ãŸå ´åˆã¯ã€ OutOfMemoryExceptionãŒç™ºç”Ÿã™ã‚‹ã¾ã§ç„¡é™ã«å¤§ãããªã‚‹ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚ 解決ç–ã®ï¼‘ã¤ã¯ã€<literal>Session</literal> ã‚ャッシュを管ç†ã™ã‚‹ãŸã‚ã«ã€ <literal>clear()</literal> ã‹ <literal>evict()</literal> を呼ã¶ã“ã¨ã§ã™ã€‚ ã—ã‹ã—ã€å¤§ããªãƒ‡ãƒ¼ã‚¿ã‚’処ç†ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãªã‚‰ã€ ãŸã¶ã‚“ストアドプãƒã‚·ãƒ¼ã‚¸ãƒ£ã‚’考慮ã™ã‚‹ã¹ãã§ã—ょã†ã€‚ ã„ãã¤ã‹ã®è§£æ±ºç–ã¯ã€<xref linkend=\"batch\"/> ã§ç´¹ä»‹ã•ã‚Œã¦ã„ã¾ã™ã€‚ ユーザーセッションã®é–“ã€<literal>Session</literal> ã‚’é–‹ã„ãŸã¾ã¾ã«ã™ã‚‹ã¨ã„ã†ã“ã¨ã¯ã€ データãŒæ–°é®®ã§ãªã!
ãªã‚‹ç¢ºçŽ‡ãŒé«˜ããªã‚‹ã“ã¨ã‚’æ„味ã—ã¾ã™ã€‚"
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "データベーストランザクション境界"
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr "データベース（もã—ãã¯ã‚·ã‚¹ãƒ†ãƒ ）トランザクションã®å¢ƒç•Œã¯ã€å¸¸ã«å¿…è¦ã§ã™ã€‚ データベーストランザクションã®å¤–ã§ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¨ã®é€šä¿¡ã¯èµ·ãã¾ã›ã‚“ （ã“ã‚Œã¯è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆãƒ¢ãƒ¼ãƒ‰ã«æ…£ã‚Œã¦ã„る多ãã®é–‹ç™ºè€…ã‚’æ··ä¹±ã•ã›ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“）。 èªã¿è¾¼ã‚€ã ã‘ã®æ“作ã«ã§ã‚‚ã€ã„ã¤ã‚‚明確ãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’使用ã—ã¦ãã ã•ã„。 分離レベルã¨ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®èƒ½åŠ›æ¬¡ç¬¬ã§ã€ã“ã‚Œã¯å¿…è¦ãªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“ãŒã€ 常ã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’明示的ã«æŒ‡å®šã—ã¦ã‚‚ã€ãƒžã‚¤ãƒŠã‚¹é¢ã¯å…¨ãã‚ã‚Šã¾ã›ã‚“。 確ã‹ã«ã€ï¼‘ã¤ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã¯å¤šæ•°ã®å°ã•ãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚ˆã‚Š （データã®èªã¿è¾¼ã¿ã§ã‚ã£ã¦ã‚‚）パフォーマンスãŒã™ãã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "J2EE環境ã«ç®¡ç†ã•ã‚Œã¦ã„ãªã„状態 （ã™ãªã‚ã¡ã€ã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ³ã€å˜ç´”ãªWebã‚„Swingアプリケーション）ã§ã‚‚〠管ç†ã•ã‚ŒãŸçŠ¶æ…‹ã§ã‚‚ã€Hibernateアプリケーションを実行ã§ãã¾ã™ã€‚ 管ç†ã•ã‚Œã¦ã„ãªã„環境ã§ã¯ã€HiberanteãŒãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールをæä¾›ã—ã¾ã™ã€‚ アプリケーション開発者ã¯ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’手動ã§è¨å®šã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 言ã„æ›ãˆã‚‹ã¨ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®é–‹å§‹ã€ã‚³ãƒŸãƒƒãƒˆã€ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã‚’ 開発者自身ãŒè¨å®šã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ 通常ã€ç®¡ç†ã•ã‚ŒãŸç’°å¢ƒã§ã¯ã€ã‚³ãƒ³ãƒ†ãƒŠç®¡ç†ã«ã‚ˆã‚‹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆCMT）ãŒæä¾›ã•ã‚Œã¾ã™ã€‚ 例ãˆã°ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³Beanã®ãƒ‡ãƒ—ãƒã‚¤ãƒ¡ãƒ³ãƒˆãƒ‡ã‚£ã‚¹ã‚¯ãƒªãƒ—ã‚¿ã§å®£è¨€çš„ã«å®šç¾©ã—〠トランザクションを組ã¿ç«‹ã¦ã¾ã™ã€‚ プãƒã‚°ãƒ©ãƒ ã«ã‚ˆã‚‹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³!
境界ã¯ã‚‚ã†å¿…è¦ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr "ã—ã‹ã—ãªãŒã‚‰ã€ç®¡ç†ã•ã‚Œã¦ã„ãªã„リソース・ãƒãƒ¼ã‚«ãƒ«ãªç’°å¢ƒã¨ JTAã«ä¾å˜ã—ãŸã‚·ã‚¹ãƒ†ãƒ （CMTã§ã¯ãªãBMT）ã®ä¸¡æ–¹ã«ã€ 永続化層をãƒãƒ¼ã‚¿ãƒ–ルã«ä¿ã¤ã®ã¯ã€ã—ã°ã—ã°æœ›ã¾ã—ã„ã“ã¨ã§ã™ã€‚ デプãƒã‚¤ç’°å¢ƒã®ãƒã‚¤ãƒ†ã‚£ãƒ–ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚·ã‚¹ãƒ†ãƒ を呼ã³å‡ºã™ <literal>Transaction</literal> ã¨ã„ã†ãƒ©ãƒƒãƒ‘ーAPIã‚’HibernateãŒæä¾›ã—ã¾ã™ã€‚ ã“ã®APIを使ã†ã‹ã¯ä»»æ„ã§ã™ãŒã€CMTã®ã‚»ãƒƒã‚·ãƒ§ãƒ³Beanを使ã‚ãªã„ã®ã§ã‚ã‚Œã°ã€ä½¿ã†ã“ã¨ã‚’å¼·ã推奨ã—ã¾ã™ã€‚"
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr "通常ã€<literal>Session</literal> 終了ã¯ã€ï¼”ã¤ã®ç•°ãªã‚‹ãƒ•ã‚§ãƒ¼ã‚ºã‚’å«ã¿ã¾ã™ã€‚"
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr "セッションã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥"
+
+#: index.docbook:395
+msgid "close the session"
+msgstr "トランザクションã®ã‚³ãƒŸãƒƒãƒˆ"
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr "セッションã®ã‚¯ãƒãƒ¼ã‚º"
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr "例外ã®ãƒãƒ³ãƒ‰ãƒªãƒ³ã‚°"
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr "セッションã®ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã«ã¤ã„ã¦ã¯ã€å‰ã®ã»ã†ã§ã™ã§ã«è°è«–ã—ã¾ã—ãŸã€‚ 管ç†ã•ã‚ŒãŸç’°å¢ƒã¨ç®¡ç†ã•ã‚Œã¦ã„ãªã„環境ã®ä¸¡æ–¹ã«ã¤ã„ã¦ã€ トランザクション境界ã¨ä¾‹å¤–ãƒãƒ³ãƒ‰ãƒªãƒ³ã‚°ã‚’ã‚‚ã£ã¨è©³ã—ã見ã¦ã„ãã¾ã—ょã†ã€‚"
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "管ç†ã•ã‚Œã¦ã„ãªã„環境"
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "Hibernate永続化層を管ç†ã•ã‚Œã¦ã„ãªã„環境ã§å®Ÿè£…ã™ã‚‹å ´åˆã¯ã€ 通常å˜ç´”ãªã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ール（ã™ãªã‚ã¡DataSourceã§ã¯ãªã„）ã«ã‚ˆã£ã¦ã€ データベースコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’制御ã—ã¾ã™ã€‚ Hibernateã¯ãã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールã‹ã‚‰å¿…è¦ãªã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å–å¾—ã—ã¾ã™ã€‚ セッションï¼ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³åˆ¶å¾¡ã®ã‚¤ãƒ‡ã‚£ã‚ªãƒ ã¯æ¬¡ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr "明示的㫠<literal>Session</literal> ã® <literal>flush()</literal> を呼ã³å‡ºã™ã¹ãã§ã¯ãªã〠<literal>commit()</literal> を呼ã³å‡ºã™ã“ã¨ã«ã‚ˆã‚Šã€è‡ªå‹•çš„ã«åŒæœŸåŒ–処ç†ãŒå®Ÿè¡Œã•ã‚Œã¾ã™ （セッション㮠<xref linkend=\"objectstate-flushing\"/>FlushMode ã«ä¾å˜ã—ã¦ã„る）。 <literal>close()</literal> を呼ã³å‡ºã™ã“ã¨ã«ã‚ˆã‚Šã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ã®çµ‚ã‚りを明確ã«ã—ã¾ã™ã€‚ <literal>close()</literal> ãŒæš—黙的ã«è¡Œã†ä¸»ãªã“ã¨ã¯ã€ セッションãŒJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’開放ã™ã‚‹ã“ã¨ã§ã™ã€‚ 上記ã®Javaコードã¯ãƒãƒ¼ã‚¿ãƒ–ルã§ã‚ã‚Šã€ç®¡ç†ã•ã‚Œã¦ã„ãªã„環境ã¨JTA環境ã®ä¸¡æ–¹ã§å®Ÿè¡Œã§ãã¾ã™ã€‚"
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr "よりé©å¿œæ€§ã®ã‚る解決ç–ã¯ã€Hibernateã«äºˆã‚組ã¿è¾¼ã¾ã‚Œã¦ã„ã‚‹ 「current sessionã€ã‚³ãƒ³ãƒ†ã‚スト管ç†ã§ã™ã€‚ 言葉ã§èª¬æ˜Žã™ã‚‹ã‚ˆã‚Šä¸‹è¨˜ã‚’見ãŸã»ã†ãŒé€Ÿã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "æ£è¦ã®ã‚¢ãƒ—リケーションã®ä¸ã§ã¯ã€ã“ã®ã‚ˆã†ãªã‚³ãƒ¼ãƒ‰ã®åˆ‡ã‚Œç«¯ã‚’決ã—ã¦è¦‹ãªã„ã§ã—ょã†ã€‚ 致命的ãªï¼ˆã‚·ã‚¹ãƒ†ãƒ ）例外ã¯ã€å¸¸ã«ã€Œæœ€ä¸Šä½ã€ã§ã‚ャッãƒã™ã¹ãã§ã™ã€‚ 言ã„æ›ãˆã‚Œã°ã€ï¼ˆæ°¸ç¶šåŒ–層ã§ï¼‰Hibernate呼ã³å‡ºã—を実行ã™ã‚‹ã‚³ãƒ¼ãƒ‰ã¨ã€ <literal>RuntimeException</literal> を制御ã™ã‚‹ （通常ã¯ã‚¯ãƒªãƒ¼ãƒ³ã‚¢ãƒƒãƒ—ã¨çµ‚了ã®ã¿è¡Œã†ã“ã¨ãŒã§ãる）コードã¯ã€åˆ¥ã€…ã®å±¤ã®ä¸ã«ã‚ã‚Šã¾ã™ã€‚ Hibernateã«ã‚ˆã‚‹ã‚«ãƒ¬ãƒ³ãƒˆã‚³ãƒ³ãƒ†ã‚スト管ç†ã¯ã€ã“ã®è¨è¨ˆã‚’ã‹ãªã‚Šå˜ç´”ã«ã—ã¾ã™ã€‚ å¿…è¦ãªã®ã¯ã€<literal>SessionFactory</literal> ã«ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã“ã¨ã ã‘ã§ã™ã€‚ 例外処ç†ã¯ã€ã“ã®ç« ã®å¾Œã®ã»ã†ã§è°è«–ã—ã¾ã™ã€‚"
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr "注æ„：（デフォルトã§ã™ãŒï¼‰ <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> ã‚’é¸æŠžã™ã‚‹ã¹ãã§ã™ã€‚ 第2ã®ç”¨ä¾‹ã¨ã—ã¦ã¯ã€ <literal>hibernate.current_session_context_class</literal> ã‚’ <literal>\"thread\"</literal> ã¨ã™ã‚‹ã¨ã‚ˆã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "JTAを使用ã™ã‚‹"
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr "永続化層をアプリケーションサーãƒãƒ¼ï¼ˆä¾‹ãˆã°ã€EJBセッションBeanã®èƒŒå¾Œï¼‰ã§å®Ÿè¡Œã™ã‚‹å ´åˆã€ Hibernateã‹ã‚‰å–å¾—ã™ã‚‹ã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ã‚½ãƒ¼ã‚¹ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã¯ã€ 自動的ã«ã‚°ãƒãƒ¼ãƒãƒ«JTAトランザクションã®ä¸€éƒ¨ã«ãªã‚Šã¾ã™ã€‚ EJBを使ã‚ãšã«ã€ã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ³ã®JTA実装を導入ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ JTAçµ±åˆã®ãŸã‚ã«ã€Hibernateã¯ï¼’ã¤ã®æˆ¦ç•¥ã‚’æä¾›ã—ã¾ã™ã€‚"
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "Bean管ç†ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ï¼ˆBMT）を使ã„ã€<literal>Transaction</literal> APIを使ã†å ´åˆã€ Hibernateã¯ã‚¢ãƒ—リケーションサーãƒãƒ¼ã«BMTトランザクションã®é–‹å§‹ã¨çµ‚ã‚ã‚Šã‚’å‘Šã’ã¾ã™ã€‚ ã™ãªã‚ã¡ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ç®¡ç†ã®ã‚³ãƒ¼ãƒ‰ã¯ã€ç®¡ç†ã•ã‚Œãªã„環境ã¨åŒã˜ã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr "トランザクション境界ã¨ã—㦠<literal>Session</literal> を使ã„ãŸã„å ´åˆã€ ç°¡å˜ã«ã‚³ãƒ³ãƒ†ã‚ストをä¼æ’ã™ã‚‹æ©Ÿèƒ½ã§ã‚ã‚‹ <literal>getCurrentSession()</literal> ãŒã‚ã‚‹ã®ã§ã€ JTAã® <literal>UserTransaction</literal> APIを直接使用ã™ã¹ãã§ã—ょã†ã€‚"
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr "CMTã§ã¯ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã‚’セッションBeanã®ãƒ‡ãƒ—ãƒã‚¤ãƒ¡ãƒ³ãƒˆãƒ‡ã‚£ã‚¹ã‚¯ãƒªãƒ—ã‚¿ã§å®šç¾©ã—〠プãƒã‚°ãƒ©ãƒ ã§ã¯è¡Œã„ã¾ã›ã‚“。 ゆãˆã«ã€ã‚³ãƒ¼ãƒ‰ã¯æ¬¡ã®ã‚ˆã†ã«å°‘ãªããªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr "CMT/EJBã®ä¸ã§ã¯ã€å¸¸ã«ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ãŒè‡ªå‹•çš„ã«å®Ÿæ–½ã•ã‚Œã¾ã™ã€‚ ãªãœãªã‚‰ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ãƒ“ーンã®ãƒ¡ã‚½ãƒƒãƒ‰ã«ã‚ˆã‚ŠæŠ•ã’られãŸåˆ¶å¾¡ã•ã‚Œã¦ã„ãªã„ <literal>RuntimeException</literal> ã¯ã€ã‚°ãƒãƒ¼ãƒãƒ«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã™ã‚‹ã‚ˆã†ã«ã‚³ãƒ³ãƒ†ãƒŠã«ä¼ãˆã‚‹ãŸã‚ã§ã™ã€‚ <emphasis>ã“ã‚Œã¯ã€BMTã‚‚ã—ãã¯CMTã¨ã„ã£ã—ょã«Hibernate <literal>Transaction</literal> APIを使ã†å¿…è¦ã¯å°‘ã—ã‚‚ãªã„ã¨ã„ã†æ„味ã§ã™ã€‚</emphasis>"
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr "Hibernateã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãƒ•ã‚¡ã‚¯ãƒˆãƒªã‚’è¨å®šã™ã‚‹éš›ã«ã€ JTAを直接使ã†ï¼ˆBMTã®ï¼‰å ´åˆã¯ <literal>org.hibernate.transaction.JTATransactionFactory</literal> を〠CMTセッションビーンã®ä¸ã§ã¯ <literal>org.hibernate.transaction.CMTTransactionFactory</literal> ã‚’ é¸æŠžã™ã¹ãã ã¨ã„ã†ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 <literal>hibernate.transaction.manager_lookup_class</literal> をセットã™ã‚‹ã“ã¨ã‚‚æ€ã„出ã—ã¦ãã ã•ã„。 ãªãŠã€<literal>hibernate.current_session_context_class</literal> ã¯ã€ セットã—ãªã„ã‹ï¼ˆå¾Œæ–¹äº’æ›ï¼‰ã€<literal>\"jta\"</literal> をセットã—ã¦ãã ã•ã„。"
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr "<literal>getCurrentSession()</literal> オペレーションã¯ã€JTA環境ã§ã¯ï¼‘ã¤ã®æ¬ 点をæŒã¡ã¾ã™ã€‚ デフォルトã§ä½¿ã‚れる <literal>after_statement</literal> コãƒã‚¯ã‚·ãƒ§ãƒ³ãƒªãƒªãƒ¼ã‚¹ãƒ¢ãƒ¼ãƒ‰ã‚’使用ã™ã‚‹ä¸Šã§ã€ è¦å‘ŠãŒï¼‘ã¤ã‚ã‚Šã¾ã™ã€‚ JTA仕様ã®æ„šã‹ãªåˆ¶ç´„ã®ãŸã‚ã«ã€ <literal>scroll()</literal> ã¾ãŸã¯ <literal>iterate()</literal> ãŒè¿”ã—ãŸã€ é–‰ã˜ã‚‰ã‚Œã¦ã„ãªã„ <literal>ScrollableResults</literal> ã¾ãŸã¯ <literal>Iterator</literal> インスタンスをHibernateãŒè‡ªå‹•çš„ã«ã‚¯ãƒªãƒ¼ãƒ³ã‚¢ãƒƒãƒ—ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 <literal>finally</literal> ブãƒãƒƒã‚¯ã®ä¸ã§ã€ <literal>ScrollableResults.close()</literal> ã¾ãŸã¯ <literal>Hibernate.close(Iterator)</literal> を明示的ã«å‘¼ã³å‡ºã—ã¦ã€ è£ã«æ½œã‚“ã データベースカーソルを解放 <emphasis>ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“</emphasis>。 （もã¡ã‚ã‚“ã€å¤šãã®ã‚¢ãƒ—リケーションã§ã¯ã€JTAã‹CMTコード㧠!
<literal>scroll()</literal> ã‚„ <literal>iterate()</literal> ã®ä½¿ç”¨ã‚’é¿ã‘ã‚‹ã®ã¯å®¹æ˜“ã§ã™ã€‚）"
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "例外ãƒãƒ³ãƒ‰ãƒªãƒ³ã‚°"
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr "<literal>Session</literal> ãŒä¾‹å¤–（<literal>SQLException</literal>ã‚’å«ã‚€ï¼‰ã‚’投ã’ãŸå ´åˆã€ ç›´ã¡ã«ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—ã€<literal>Session.close()</literal> を呼ã³ã€<literal>Session</literal> ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’ç ´æ£„ã™ã¹ãã§ã™ã€‚ <literal>Session</literal> ã®ã„ãã¤ã‹ã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ã€ セッションã®çŠ¶æ…‹ã‚’ <emphasis>矛盾ã—ãŸã¾ã¾</emphasis> ã«ã—ã¾ã™ã€‚ HibernateãŒæŠ•ã’ãŸä¾‹å¤–ã‚’ã€å›žå¾©ã§ãã‚‹ã‚‚ã®ã¨ã—ã¦æ‰±ã†ã“ã¨ã¯ã§ãã¾ã›ã‚“。 <literal>finally</literal> ブãƒãƒƒã‚¯ã®ä¸ã§ <literal>close()</literal> を呼んã§ã€ <literal>Session</literal> を確実ã«é–‰ã˜ã¦ãã ã•ã„。"
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "<literal>HibernateException</literal> ã¯ã€Hibernate永続化層ã®ä¸ã§ç™ºç”Ÿã™ã‚‹å¤šãã®ã‚¨ãƒ©ãƒ¼ã‚’ ラップã™ã‚‹ã€æ¤œæŸ»ã•ã‚Œãªã„例外ã§ã™ï¼ˆHibernateã®å¤ã„ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¯é•ã„ã¾ã—ãŸï¼‰ã€‚ ç§ãŸã¡ã®æ„見ã¯ã€ã‚¢ãƒ—リケーション開発者ã«å›žå¾©ä¸å¯èƒ½ãªä¾‹å¤–ã‚’ 下層ã§ã‚ャッãƒã™ã‚‹ã“ã¨ã‚’å¼·è¦ã™ã¹ãã§ã¯ãªã„ã¨ã„ã†ã“ã¨ã§ã™ã€‚ 多ãã®ã‚·ã‚¹ãƒ†ãƒ ã§ã¯ã€æ¤œæŸ»ã•ã‚Œãªã„例外ã¨è‡´å‘½çš„ãªä¾‹å¤–ã¯ã€ コールスタックã®æœ€åˆã®ãƒ•ãƒ¬ãƒ¼ãƒ ã®ï¼‘ã¤ï¼ˆä¾‹ãˆã°ã€æœ€ä¸Šä½ã®å±¤ã§ï¼‰ã§ãƒãƒ³ãƒ‰ãƒªãƒ³ã‚°ã—〠エラーメッセージをアプリケーションユーザーã«è¡¨ç¤ºã—ã¾ã™ （もã—ãã¯ã€ä»–ã®é©åˆ‡ãªå‡¦ç†ã‚’実施ã—ã¾ã™ï¼‰ã€‚ Hibernateã¯ã€<literal>HibernateException</literal> 以外ã®æ¤œæŸ»ã•ã‚Œãªã„例外も 投ã’ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“れらもã¾ãŸã€å›žå¾©ä¸å¯èƒ½ã§ã‚ã‚Šã€é©åˆ‡ãªå‡¦ç†ã‚’実施ã™ã¹ãã§ã™ã€‚"
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr "Hibernateã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¨ã®å¯¾è©±ä¸ã«æŠ•ã’られ㟠<literal>SQLException</literal> ã‚’ <literal>JDBCException</literal> ã§ãƒ©ãƒƒãƒ—ã—ã¾ã™ã€‚ 実ã¯ã€ä¾‹å¤–をよりæ„味ã®ã‚ã‚‹ <literal>JDBCException</literal> ã®ã‚µãƒ–クラス㫠変æ›ã—よã†ã¨è©¦ã¿ã¾ã™ã€‚ 元㮠<literal>SQLException</literal> ã¯ã€<literal>JDBCException.getCause()</literal> ã«ã‚ˆã‚Šã„ã¤ã§ã‚‚得られã¾ã™ã€‚ Hibernateã¯ã€<literal>SessionFactory</literal> ã«è¿½åŠ ã•ã‚Œã¦ã„ã‚‹ <literal>SQLExceptionConverter</literal> を使ã„ã€<literal>SQLException</literal> ã‚’ é©å½“㪠<literal>JDBCException</literal> サブクラスã«å¤‰æ›ã—ã¾ã™ã€‚ デフォルトã§ã¯ã€<literal>SQLExceptionConverter</literal> ã¯è¨å®šã•ã‚Œã¦ã„ã‚‹SQL方言ã«ã‚ˆã‚Š 定義ã•ã‚Œã¾ã™ã€‚ 一方ã§ã€ç‹¬è‡ªã®å®Ÿè£…ã«å·®ã—替ãˆã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ （詳細ã¯ã€<literal>SQLExceptionConverterFactory</literal> クラスã®Javadocã‚’å‚ç…§ã—ã¦ãã ã•ã„）。 標æº!
–的㪠<literal>JDBCException</literal> ã®ã‚µãƒ–タイプを下記ã«ç¤ºã—ã¾ã™ã€‚"
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr "<literal>JDBCConnectionException</literal> - 基礎ã¨ãªã‚‹JDBC通信ã®ã‚¨ãƒ©ãƒ¼ã‚’表ã—ã¾ã™ã€‚"
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr "<literal>SQLGrammarException</literal> - 発行ã™ã‚‹SQLã®æ–‡æ³•ã‚‚ã—ãã¯æ§‹æ–‡ã®å•é¡Œã‚’表ã—ã¾ã™ã€‚"
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "<literal>ConstraintViolationException</literal> - 何らã‹ã®å½¢å¼ã®å®Œå…¨æ€§åˆ¶ç´„é•åを表ã—ã¾ã™ã€‚"
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr "<literal>LockAcquisitionException</literal> - è¦æ±‚ã•ã‚ŒãŸæ“作を実施ã™ã‚‹ã®ã«å¿…è¦ãªãƒãƒƒã‚¯ãƒ¬ãƒ™ãƒ«ã‚’å¾—ã‚‹éš›ã®ã‚¨ãƒ©ãƒ¼ã‚’表ã—ã¾ã™ã€‚"
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr "<literal>GenericJDBCException</literal> - ä»–ã®ã‚«ãƒ†ã‚´ãƒªã«ä¸€è‡´ã—ãªã‹ã£ãŸä¸€èˆ¬çš„ãªä¾‹å¤–ã§ã™ã€‚"
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "トランザクションã®ã‚¿ã‚¤ãƒ アウト"
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr "EJBã®ã‚ˆã†ãªç®¡ç†ã•ã‚ŒãŸç’°å¢ƒãŒæä¾›ã™ã‚‹ãã‚ã‚ã¦é‡è¦ãªç‰¹å¾´ã®ï¼‘ã¤ã¯ã€ トランザクションã®ã‚¿ã‚¤ãƒ アウトã§ã™ã€‚ ã“ã‚Œã¯ç®¡ç†ã•ã‚Œã¦ã„ãªã„コードã«ã¯æä¾›ã§ãã¾ã›ã‚“。 トランザクションタイムアウトã¯ã€ä¸å“è¡Œãªãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ãŒ ユーザーã«ãƒ¬ã‚¹ãƒãƒ³ã‚¹ã‚’è¿”ã•ãªã„ã¾ã¾ã€ç„¡æœŸé™ã«ãƒªã‚½ãƒ¼ã‚¹ã‚’使ã„続ã‘ãªã„ ã“ã¨ã‚’ä¿éšœã—ã¾ã™ã€‚ 管ç†ã•ã‚ŒãŸç’°å¢ƒï¼ˆJTA）ã®å¤–ã§ã¯ã€Hibernateã¯ã“ã®æ©Ÿèƒ½ã‚’フルã«æä¾›ã§ãã¾ã›ã‚“。 ã—ã‹ã—ãªãŒã‚‰ã€Hibernateã¯æ¬¡ã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹æ“作ã®åˆ¶å¾¡ãらã„ã¯ã§ãã¾ã™ã€‚ データベースレベルã®ãƒ‡ãƒƒãƒ‰ãƒãƒƒã‚¯ã‚„大ããªãƒªã‚¶ãƒ«ãƒˆã‚»ãƒƒãƒˆã‚’è¿”ã™ã‚¯ã‚¨ãƒªã‚’ 定義ã•ã‚ŒãŸã‚¿ã‚¤ãƒ アウトã«ã‚ˆã£ã¦ç¢ºå®Ÿã«åˆ¶é™ã—ã¾ã™ã€‚ 管ç†ã•ã‚ŒãŸç’°å¢ƒã§ã¯ã€Hibernateã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚¿ã‚¤ãƒ アウトをJTAã«å§”è²ã—ã¾ã™ã€‚ ã“ã®æ©Ÿèƒ½ã¯ã€Hibernateã® <lite!
ral>Transaction</literal> オブジェクト㫠よã£ã¦æŠ½è±¡åŒ–ã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr "CMTビーンã®ä¸ã§ã¯ <literal>setTimeout()</literal> ã‚’ 呼ã³å‡ºã›ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 トランザクションタイムアウトã¯å®£è¨€çš„ã«å®šç¾©ã•ã‚Œã‚‹ã¹ãã§ã™ã€‚"
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "楽観的åŒæ™‚実行制御"
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr "高ã„並列性ã¨é«˜ã„スケーラビリティã®ä¸¡æ–¹ã‚’実ç¾ã™ã‚‹ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€ ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã‚’使ã£ãŸæ¥½è¦³çš„åŒæ™‚実行制御ã®ã¿ã§ã™ã€‚ æ›´æ–°ã®è¡çªã‚’見ã¤ã‘ã‚‹ãŸã‚ã«ï¼ˆãŠã‚ˆã³ã€æ›´æ–°ãŒå¤±ã‚れるã®ã‚’防ããŸã‚ã«ï¼‰ã€ ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã‚‚ã—ãã¯ã‚¿ã‚¤ãƒ スタンプを使ã£ã¦ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚ Hibernateã¯ã€æ¥½è¦³çš„åŒæ™‚実行を行ã†ã‚¢ãƒ—リケーションコードを書ããŸã‚㮠アプãƒãƒ¼ãƒã‚’３ã¤æä¾›ã—ã¾ã™ã€‚ ç§ãŸã¡ãŒè¦‹ã›ã‚‹ãƒ¦ãƒ¼ã‚¹ã‚±ãƒ¼ã‚¹ã¯ã€é•·ã„対話をæŒã¡ã¾ã™ãŒã€ ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã¯ã¾ã １ã¤ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ä¸ã§æ›´æ–°ã‚’失ã†ã“ã¨ã‚’防ã 利点もæŒã£ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr "アプリケーションã«ã‚ˆã‚‹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯"
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr "Hibernateã«ã»ã¨ã‚“ã©åŠ©ã‘ã¦ã‚‚らã‚ãšã«å®Ÿè£…ã™ã‚‹ã‚±ãƒ¼ã‚¹ã§ã™ã€‚ データベースã¨ã®ã‚„ã‚Šå–ã‚Šã¯ã€ãã‚Œãžã‚Œæ–°ã—ã„ <literal>Session</literal> ã®ä¸ã§èµ·ã“ã‚Šã¾ã™ã€‚ 開発者ã¯ã€ã™ã¹ã¦ã®æ°¸ç¶šæ€§ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’æ“作ã™ã‚‹å‰ã«ã€ データベースã‹ã‚‰å†èªã¿è¾¼ã¿ã™ã‚‹è²¬å‹™ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã§ã¯ã€å¯¾è©±ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®åˆ†é›¢ã‚’守るãŸã‚ã«ã€ アプリケーション自身ãŒãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã‚’è¡Œã†å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¢ã‚¯ã‚»ã‚¹ã®ä¸ã§ã¯ã€æœ€ã‚‚éžåŠ¹çŽ‡ã§ã™ã€‚ エンティティEJBã¨æœ€ã‚‚ä¼¼ã¦ã„るアプãƒãƒ¼ãƒã§ã™ã€‚"
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "<literal><version></literal> を使ã£ã¦ã€<literal>version</literal> プãƒãƒ‘ティをマッピングã—ã¾ã™ã€‚ Hibernateã¯ã€ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã‚‹å ´åˆã€ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã—〠ãã®é–“ã« <literal>version</literal> プãƒãƒ‘ティを自動的ã«ã‚¤ãƒ³ã‚¯ãƒªãƒ¡ãƒ³ãƒˆã—ã¾ã™ã€‚"
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "ã‚‚ã¡ã‚ã‚“ã€ãƒ‡ãƒ¼ã‚¿ã®ä¸¦åˆ—性ãŒä½Žã„環境ã§é‹ç”¨ã—ã¦ãŠã‚Šã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ãŒä¸è¦ãªã‚‰ã€ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã‚’使ã„ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã‚’スã‚ップã™ã‚‹ã ã‘ã§ã™ã€‚ ãã®å ´åˆã¯ã€é•·ã„対話ã«ã¯ã€ <emphasis>「最後ã«ã‚³ãƒŸãƒƒãƒˆã—ãŸã‚‚ã®ãŒå‹ã¤ã€</emphasis> ãŒãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®æˆ¦ç•¥ã§ã—ょã†ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€ã‚¢ãƒ—リケーションã®ãƒ¦ãƒ¼ã‚¶ãƒ¼ã‚’æ··ä¹±ã•ã›ã‚‹ã‹ã‚‚ã—ã‚Œãªã„ã“ã¨ã‚’ 心ã«ç•™ã‚ã¦ç½®ã„ã¦ãã ã•ã„。ãã‚Œã¯ã€ã‚¨ãƒ©ãƒ¼ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ã‚„競åˆã—ãŸå¤‰æ›´ã‚’マージã™ã‚‹æ©Ÿä¼šãŒ ãªã„ã¾ã¾ã€æ›´æ–°ã‚’失ã†çµŒé¨“ã‚’ã™ã‚‹ãŸã‚ã§ã™ã€‚"
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr "確ã‹ã«ã€ãƒžãƒ‹ãƒ¥ã‚¢ãƒ«ã«ã‚ˆã‚‹ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã¯ã€äº›ç´°ãªå„€å¼ã ã‘ã§å®Ÿè¡Œã§ãã¾ã™ãŒã€ 多ãã®ã‚¢ãƒ—リケーションã«ã¨ã£ã¦å®Ÿç”¨çš„ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ã—ã°ã—ã°ã€ï¼‘ã¤ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã ã‘ã§ãªã〠修æ£ã•ã‚ŒãŸã‚ªãƒ–ジェクトã®å®Œå…¨ãªã‚°ãƒ©ãƒ•ã‚’ãƒã‚§ãƒƒã‚¯ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 Hibernateã¯ã€è¨è¨ˆãƒ‘ラダイムã¨ã—ã¦ã€æ‹¡å¼µ <literal>Session</literal> ㋠分離ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’自動的ã«ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚"
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr "拡張セッションã¨è‡ªå‹•ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°"
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr "１ã¤ã® <literal>Session</literal> インスタンスã¨ãã®æ°¸ç¶šæ€§ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ã€ <emphasis>session-per-conversation</emphasis> ã¨ã—ã¦çŸ¥ã‚‰ã‚Œã‚‹ã€ 対話全体ã§ä½¿ã‚ã‚Œã¾ã™ã€‚ Hibernateã¯ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã™ã‚‹éš›ã«ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚ åŒæ™‚ã«ä¿®æ£ã•ã‚ŒãŸã“ã¨ã‚’検出ã™ã‚‹ã¨ã€ä¾‹å¤–を投ã’ã¾ã™ã€‚ ã“ã®ä¾‹å¤–ã‚’ã‚ャッãƒã—ã¦æ‰±ã†ã®ã¯ã€é–‹ç™ºè€…ã®è²¬ä»»ã§ã™ （一般的ãªé¸æŠžè‚¢ã¯ã€å¤‰æ›´ã‚’マージã™ã‚‹ã‹å¤ããªã„データã§ãƒ“ジãƒã‚¹å¯¾è©±ã‚’ å†ã‚¹ã‚¿ãƒ¼ãƒˆã™ã‚‹æ©Ÿä¼šã‚’ユーザーã«æä¾›ã™ã‚‹ã“ã¨ã§ã™ï¼‰ã€‚"
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr "ユーザーã®å¯¾è©±ã‚’å¾…ã£ã¦ã„ã‚‹ã¨ãã¯ã€ <literal>Session</literal> を基礎ã¨ãªã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‹ã‚‰åˆ‡ã‚Šé›¢ã—ã¾ã™ã€‚ ã“ã®ã‚¢ãƒ—ãƒãƒ¼ãƒã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¢ã‚¯ã‚»ã‚¹ã®ä¸ã§ã¯ã€æœ€ã‚‚効率的ã§ã™ã€‚ アプリケーションã¯ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã‚„分離ã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’å†è¿½åŠ ã™ã‚‹ã“㨠ã«é–¢å¿ƒã‚’æŒã¤å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。ã¾ãŸã€ã‚らゆるデータベーストランザクションã®ä¸ã§ インスタンスをå†èªã¿è¾¼ã¿ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr "<literal>foo</literal> オブジェクトã¯ã€è‡ªåˆ†ã‚’ãƒãƒ¼ãƒ‰ã—㟠<literal>Session</literal> ã‚’ã¾ã 知ã£ã¦ã„ã¾ã™ã€‚ å¤ã„セッションã®ä¸Šã§æ–°ã—ã„データベーストランザクションを開始ã™ã‚‹ã“ã¨ã§ã€ æ–°ã—ã„コãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å–å¾—ã—ã€ãã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ãŒå†é–‹ã•ã‚Œã¾ã™ã€‚ データベーストランザクションをコミットã™ã‚‹ã“ã¨ã§ã€ セッションã‹ã‚‰JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’切æ–ã—ã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’プールã«è¿”ã—ã¾ã™ã€‚ å†æŽ¥ç¶šã—ãŸå¾Œã€æ›´æ–°ã—ã¦ã„ãªã„データã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã‚’強制ã™ã‚‹ãŸã‚ã«ã€ ä»–ã®ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã«ã‚ˆã‚Šæ›´æ–°ã•ã‚Œã¦ã„ã‚‹ã‹ã‚‚ã—ã‚Œãªã„オブジェクトã«é–¢ã—ã¦ã€ <literal>LockMode.READ</literal> ã‚’ã¤ã‘㦠<literal>Session.lock()</literal> を呼ã³å‡ºã™ã“ã¨ãŒã§ãã¾ã™ã€‚ æ›´æ–°ã—㦠<emphasis>ã„ã‚‹</emphasis> データをãƒãƒƒã‚¯ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。 通常ã€æ‹¡å¼µ <literal>Session<!
/literal> ã« <literal>FlushMode.MANUAL</literal> をセットã—ã¾ã™ã€‚ 最後ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®å‘¨æœŸã§ã®ã¿ã€ 対話ã®ä¸ã§å¤‰æ›´ã•ã‚ŒãŸã™ã¹ã¦ã‚’実際ã«æ°¸ç¶šåŒ–ã•ã›ã‚‹ãŸã‚ã§ã™ã€‚ ゆãˆã«ã€æœ€å¾Œã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ã¿ <literal>flush()</literal> オペレーションをå«ã¿ã¾ã™ã€‚ãã—ã¦ã€å¯¾è©±ã‚’終ã‚らã›ã‚‹ãŸã‚ã«ã€ セッションも <literal>close()</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr "ユーザーãŒè€ƒæ…®ä¸ã«ã€æ ¼ç´ã™ã‚‹ã“ã¨ãŒã§ããªã„ãらㄠ<literal>Session</literal> ãŒå¤§ãã„ã®ã§ã‚ã‚Œã°ã€ã“ã®ãƒ‘ターンã¯å•é¡ŒãŒã‚ã‚Šã¾ã™ã€‚ 例ãˆã°ã€<literal>HttpSession</literal> ã¯å¯èƒ½ãªé™ã‚Šå°ã•ãä¿ã¤ã¹ãã§ã™ã€‚ <literal>Session</literal> ã¯ï¼ˆå¼·åˆ¶çš„ã«ï¼‰ï¼‘次ã‚ャッシュã§ã‚‚ã‚り〠ãƒãƒ¼ãƒ‰ã—ãŸã‚ªãƒ–ジェクトをã™ã¹ã¦ä¿æŒã—ã¾ã™ã€‚ ãŠãらãã€ãƒªã‚¯ã‚¨ã‚¹ãƒˆï¼ãƒ¬ã‚¹ãƒãƒ³ã‚¹ã®ã‚µã‚¤ã‚¯ãƒ«ãŒæ•°å›žã§ã‚ã‚Œã°ã€ã“ã®æˆ¦ç•¥ãŒä½¿ãˆã¾ã™ã€‚ １ã¤ã®å¯¾è©±ã®ãŸã‚ã ã‘ã« <literal>Session</literal> を使ã†ã¹ãã§ã™ã€‚ ãªãœãªã‚‰ã€ã™ãã«æ–°é®®ã§ãªã„データをæŒã¤ãŸã‚ã§ã™ã€‚"
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr "（Hibernateã®ä»¥å‰ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¯ã€æ˜Žç¤ºçš„㪠<literal>Session</literal> 㮠切æ–ã¨å†æŽ¥ç¶šãŒå¿…è¦ã ã£ãŸã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“れらã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯éžæŽ¨å¥¨ã«ãªã‚Šã¾ã—ãŸã€‚ ãªãœãªã‚‰ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®é–‹å§‹ã¨çµ‚了ã¯åŒã˜åŠ¹æžœãŒã‚ã‚‹ãŸã‚ã§ã™ã€‚）"
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr "切æ–ã—㟠<literal>Session</literal> を永続化層ã®è¿‘ãã§ä¿æŒã™ã¹ãã§ã‚ã‚‹ã“ã¨ã« 注æ„ã—ã¦ãã ã•ã„。 言ã„æ›ãˆã‚‹ã¨ã€ï¼“層環境ã®ä¸ã§ <literal>Session</literal> ã‚’ä¿æŒã™ã‚‹ãŸã‚ã«ã€ EJBステートフルセッションBeanを使ã£ã¦ãã ã•ã„。 <literal>HttpSession</literal> ã«æ ¼ç´ã™ã‚‹ãŸã‚ã«ã€Web層ã«è»¢é€ã—ãªã„ã§ãã ã•ã„ （別ã®å±¤ã¸ã®ã‚·ãƒªã‚¢ãƒ©ã‚¤ã‚ºã‚‚ã—ãªã„ã§ãã ã•ã„）。"
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr "拡張セッションパターン（もã—ãã¯ã€<emphasis>session-per-conversation</emphasis>）ã¯ã€ 自動的ãªã‚«ãƒ¬ãƒ³ãƒˆã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚³ãƒ³ãƒ†ã‚スト管ç†ã‚’実施ã™ã‚‹ã‚ˆã‚Šé›£ã—ã„。 ã“ã®ãŸã‚ã«ã€ã‚ãªãŸã¯ <literal>CurrentSessionContext</literal> ã®å®Ÿè£…を供給ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ Hibernate Wikiã«ã‚る例をå‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr "デタッãƒã•ã‚ŒãŸã‚ªãƒ–ジェクトã¨è‡ªå‹•ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr "æ–°ã—ã„ <literal>Session</literal>ã«ã‚ˆã‚Šã€æ°¸ç¶šåŒ–ストア（訳注：ＤＢ）ã¨ã®å¯¾è©±ãŒç™ºç”Ÿã—ã¾ã™ã€‚ ã¾ãŸä¸€æ–¹ã€åŒã˜æ°¸ç¶šæ€§ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¨ã®å¯¾è©±ã”ã¨ã«å†åˆ©ç”¨ã•ã‚Œã¾ã™ã€‚ アプリケーションã¯ã€å…ƒã€…ã¯ä»–ã® <literal>Session</literal> ã§ãƒãƒ¼ãƒ‰ã•ã‚Œã€ デタッãƒã•ã‚ŒãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®çŠ¶æ…‹ã‚’æ“作ã—ã¾ã™ã€‚ ãã—ã¦ã€<literal>Session.update()</literal> ã‚‚ã—ãã¯ã€<literal>Session.saveOrUpdate()</literal>〠<literal>Session.merge()</literal> を使ã£ã¦ã€ãれらã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’å†è¿½åŠ ã—ã¾ã™ã€‚"
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr "ã“ã®å ´åˆã‚‚ã‚„ã¯ã‚Šã€Hibernateã¯ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã™ã‚‹éš›ã«ã€ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¾ã™ã€‚ æ›´æ–°ã®ç«¶åˆãŒç™ºç”Ÿã—ãŸå ´åˆã«ã¯ã€ä¾‹å¤–を投ã’ã¾ã™ã€‚"
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr "オブジェクトãŒä¿®æ£ã•ã‚Œã¦ã„ãªã„ã“ã¨ã‚’確信ã—ã¦ã„ã‚‹å ´åˆã¯ã€ <literal>update()</literal> ã®ä»£ã‚ã‚Šã«ã€<literal>LockMode.READ</literal> を使ã£ã¦ã€ <literal>lock()</literal> を呼ã³å‡ºã™ã“ã¨ã‚‚ã§ãã¾ã™ （ã™ã¹ã¦ã®ã‚ャッシュを迂回ã—ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã‚’実施ã—ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "自動ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã®ã‚«ã‚¹ã‚¿ãƒžã‚¤ã‚º"
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr "マッピング㮠<literal>optimistic-lock</literal> 属性㫠<literal>false</literal> ã‚’è¨å®šã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šã€ç‰¹å®šã®ãƒ—ãƒãƒ‘ティやコレクションã®ãŸã‚㫠自動ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚¤ãƒ³ã‚¯ãƒªãƒ¡ãƒ³ãƒˆã‚’無効ã«ã§ãã¾ã™ã€‚ プãƒãƒ‘ティãŒãƒ€ãƒ¼ãƒ†ã‚£ã§ã‚ã£ã¦ã‚‚ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚’インクリメントã—ã¾ã›ã‚“。"
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr "レガシーã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã¯ã€ã—ã°ã—ã°å›ºå®šçš„ã§ã‚ã‚Šã€å¤‰æ›´ã§ãã¾ã›ã‚“。 ã¾ãŸã¯ã€ä»–ã®ã‚¢ãƒ—リケーションãŒåŒã˜ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãªã‘ã‚Œã°ãªã‚‰ãšã€ ãã®ã‚¢ãƒ—リケーションã¯ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã‚„タイムスタンプã•ãˆæ“作ã™ã‚‹æ–¹æ³•ã‚’知りã¾ã›ã‚“。 ã©ã¡ã‚‰ã®å ´åˆã‚‚ã€ãƒ†ãƒ¼ãƒ–ルã®ç‰¹å®šã®ã‚«ãƒ©ãƒ を当ã¦ã«ã—ã¦ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ‹ãƒ³ã‚°ã‚’è¡Œãˆã¾ã›ã‚“。 ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‚„タイムスタンプã®ãƒ—ãƒãƒ‘ティをマッピングã›ãšã«ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã•ã›ã‚‹ãŸã‚ã«ã€ <literal><class></literal> マッピング㫠<literal>optimistic-lock=\"all\"</literal> ã‚’ 指定ã—ã¦ãã ã•ã„。 è¡Œã®ã™ã¹ã¦ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã®çŠ¶æ…‹ã‚’比較ã™ã‚‹ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚ ã“ã‚Œã¯ã€HibernateãŒå¤ã„状態ã¨æ–°ã—ã„状態を比較ã§ãã‚‹å ´åˆã«ã€ ç†è«–çš„ã«å‹•ä½œã™ã‚‹ã ã‘ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 例ãˆã!
°ã€session-per-request-with-detached-objects ã§ã¯ãªã〠１ã¤ã®é•·ã„ <literal>Session</literal> を使ã†å ´åˆã§ã™ã€‚"
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr "ã¨ãã©ãã€è¡Œã‚ã‚ŒãŸå¤‰æ›´ãŒé‡ãªã‚‰ãªã„é™ã‚Šã€åŒæ™‚ã«è¡Œã‚ã‚ŒãŸå¤‰æ›´ã‚’å—ã‘入れるã“ã¨ãŒã§ãã¾ã™ã€‚ <literal><class></literal> マッピング㫠<literal>optimistic-lock=\"dirty\"</literal> ã‚’è¨å®šã—ãŸå ´åˆã€ãƒ•ãƒ©ãƒƒã‚·ãƒ¥ã™ã‚‹éš›ã«ã€Hibernateã¯ãƒ€ãƒ¼ãƒ†ã‚£ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã®ã¿ã‚’比較ã—ã¾ã™ã€‚"
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr "専用ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ï¼ã‚¿ã‚¤ãƒ スタンプã®ã‚«ãƒ©ãƒ を使ã†å ´åˆã€ ã‚‚ã—ãã¯ã™ã¹ã¦ï¼ãƒ€ãƒ¼ãƒ†ã‚£ã®ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã‚’比較ã™ã‚‹å ´åˆã©ã¡ã‚‰ã§ã‚ã£ã¦ã‚‚〠Hibernateã¯ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã”ã¨ã«1ã¤ã® <literal>UPDATE</literal> 文を （é©åˆ‡ãª <literal>WHERE</literal> 節ã¨å…±ã«ï¼‰ä½¿ã„〠ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãƒã‚§ãƒƒã‚¯ã¨æƒ…å ±ã®æ›´æ–°ã‚’è¡Œã„ã¾ã™ã€‚ 関連ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®å†è¿½åŠ をカスケードã™ã‚‹ãŸã‚ã«ã€ 連鎖的ãªæ°¸ç¶šåŒ–を使用ã—ãŸå ´åˆã€ä¸å¿…è¦ãªæ›´æ–°ã‚’実行ã™ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 ã“ã‚Œã¯é€šå¸¸å•é¡Œã«ãªã‚Šã¾ã›ã‚“。 ã—ã‹ã—ã€åˆ†é›¢ã—ãŸã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’変更ã—ã¦ã„ãªãã¨ã‚‚〠データベース㮠<emphasis>on update</emphasis> トリガーãŒå®Ÿè¡Œã•ã‚Œã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 <literal><class></literal> マッピング㫠<literal>select-before-update=\"true\"</literal> ã‚’è¨å®šã™ã‚‹ã“ã¨ã«ã‚ˆã£ã¦ã€ ã“ã®æŒ¯ã‚‹èˆžã„をカスタマイズã§ã!
ã¾ã™ã€‚ 確実ã«å¤‰æ›´ã•ã‚ŒãŸã‹ã‚’確èªã™ã‚‹ãŸã‚ã«ã€è¡Œã‚’æ›´æ–°ã™ã‚‹å‰ã«ã€ å¿…ãšã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’ <literal>SELECT</literal> ã—ã¾ã™ã€‚"
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr "悲観的ãƒãƒƒã‚¯"
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr "ユーザãŒãƒãƒƒã‚¯æˆ¦ç•¥ã«æ‚©ã‚€ã®ã«å¤šãã®æ™‚間を費やã™ã“ã¨ã‚’æ„図ã—ã¦ã„ã¾ã›ã‚“。 通常ã¯ã€JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã«åˆ†é›¢ãƒ¬ãƒ™ãƒ«ã‚’指定ã—〠å˜ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã™ã¹ã¦ã®ä»•äº‹ã‚’ã•ã›ã‚Œã°å分ã§ã™ã€‚ ã—ã‹ã—ãªãŒã‚‰ã€é«˜åº¦ãªãƒ¦ãƒ¼ã‚¶ã¯ã€æŽ’ä»–çš„ãªæ‚²è¦³çš„ãƒãƒƒã‚¯ã‚’ç²å¾—ã™ã‚‹ã“ã¨ã‹ã€ æ–°ã—ã„トランザクションãŒé–‹å§‹ã•ã‚Œã‚‹éš›ã«ãƒãƒƒã‚¯ã‚’å†ç²å¾—ã™ã‚‹ã“ã¨ã‚’ ã¨ãã©ã望むã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "Hibernateã¯ã„ã¤ã‚‚データベースã®ãƒãƒƒã‚¯ã®ä»•çµ„ã¿ã‚’使ã„ã¾ã™ã€‚ メモリ内ã®ã‚ªãƒ–ジェクトを決ã—ã¦ãƒãƒƒã‚¯ã—ã¾ã›ã‚“ï¼"
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "<literal>LockMode</literal> クラスã¯ã€HibernateãŒç²å¾—ã§ãã‚‹ç•°ãªã‚‹ãƒãƒƒã‚¯ãƒ¬ãƒ™ãƒ«ã‚’定義ã—ã¾ã™ã€‚ 以下ã®ä»•çµ„ã¿ã«ã‚ˆã‚Šã€ãƒãƒƒã‚¯ã‚’ç²å¾—ã§ãã¾ã™ã€‚"
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "<literal>LockMode.WRITE</literal> ã¯ã€ HibernateãŒè¡Œã‚’æ›´æ–°ã‚‚ã—ãã¯æŒ¿å…¥ã™ã‚‹éš›ã«è‡ªå‹•çš„ã«å¾—られã¾ã™ã€‚"
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "<literal>LockMode.UPGRADE</literal> ã¯ã€ データベースã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„る文法 <literal>SELECT ... FOR UPDATE</literal> を使ã£ãŸã€æ˜Žç¤ºçš„ãªãƒ¦ãƒ¼ã‚¶ãƒ¼è¦æ±‚ã«ã‚ˆã‚Šå¾—られるã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr "<literal>LockMode.UPGRADE_NOWAIT</literal> ã¯ã€ Oracle 㧠<literal>SELECT ... FOR UPDATE NOWAIT</literal> を使ã£ãŸã€ 明示的ãªãƒ¦ãƒ¼ã‚¶ãƒ¼è¦æ±‚ã«ã‚ˆã‚Šå¾—られるã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr "<literal>LockMode.READ</literal> ã¯ã€ Repeatable Readã‚‚ã—ãã¯Serializableã®åˆ†é›¢ãƒ¬ãƒ™ãƒ«ã§ã€ãƒ‡ãƒ¼ã‚¿ã‚’èªã‚“ã éš›ã«è‡ªå‹•çš„ã«å¾—られã¾ã™ã€‚ ãŠãらãã€æ˜Žç¤ºçš„ãªãƒ¦ãƒ¼ã‚¶ãƒ¼è¦æ±‚ã«ã‚ˆã‚Šã€å†å–å¾—ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr "<literal>LockMode.NONE</literal> ã¯ã€ãƒãƒƒã‚¯ã—ãªã„ã“ã¨ã‚’表ã—ã¾ã™ã€‚ <literal>Transaction</literal> ã®çµ‚ã‚ã‚Šã«ã€ ã™ã¹ã¦ã®ã‚ªãƒ–ジェクトã¯ã“ã®ãƒãƒƒã‚¯ãƒ¢ãƒ¼ãƒ‰ã«åˆ‡ã‚Šæ›¿ã‚ã‚Šã¾ã™ã€‚ <literal>update()</literal> ã‚„ <literal>saveOrUpdate()</literal> を呼ã³å‡ºã™ã“ã¨ã«ã‚ˆã£ã¦ã€ セッションã«é–¢é€£ä»˜ã‘られãŸã‚ªãƒ–ジェクトもã€ã“ã®ãƒãƒƒã‚¯ãƒ¢ãƒ¼ãƒ‰ã§å‡ºç™ºã—ã¾ã™ã€‚"
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr "「明示的ãªãƒ¦ãƒ¼ã‚¶ãƒ¼è¦æ±‚ã€ã¨ã¯ã€ä¸‹è¨˜ã®æ–¹æ³•ã®ï¼‘ã¤ã§è¨€ã„表ã›ã¾ã™ã€‚"
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr "<literal>LockMode</literal> を指定ã—㟠<literal>Session.load()</literal> ã®å‘¼ã³å‡ºã—。"
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr "<literal>Session.lock()</literal> ã®å‘¼ã³å‡ºã—。"
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr "<literal>Query.setLockMode()</literal> ã®å‘¼ã³å‡ºã—。"
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr "<literal>UPGRADE</literal> ã‚‚ã—ã㯠<literal>UPGRADE_NOWAIT</literal> ãŒæŒ‡å®šã•ã‚ŒãŸ <literal>Session.load()</literal> ãŒå‘¼ã³å‡ºã•ã‚Œã€ ã‹ã¤è¦æ±‚ã•ã‚ŒãŸã‚ªãƒ–ジェクトãŒã‚»ãƒƒã‚·ãƒ§ãƒ³ã«ã‚ˆã£ã¦ã¾ã ãƒãƒ¼ãƒ‰ã•ã‚Œã¦ã„ãªã‹ã£ãŸå ´åˆã¯ã€ <literal>SELECT ... FOR UPDATE</literal> を使ã£ã¦ã€ã‚ªãƒ–ジェクトãŒãƒãƒ¼ãƒ‰ã•ã‚Œã¾ã™ã€‚ <literal>load()</literal> ã§å‘¼ã³å‡ºã•ã‚ŒãŸã‚ªãƒ–ジェクトãŒã€ è¦æ±‚ã•ã‚Œã¦ã„るより制é™ãŒå°‘ãªã„ãƒãƒƒã‚¯ã§ã™ã§ã«ãƒãƒ¼ãƒ‰ã•ã‚Œã¦ã„ãŸå ´åˆã¯ã€ Hibernateã¯ãã®ã‚ªãƒ–ジェクトã®ãŸã‚ã«ã€<literal>lock()</literal> を呼ã³å‡ºã—ã¾ã™ã€‚"
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr "指定ã•ã‚ŒãŸãƒãƒƒã‚¯ãƒ¢ãƒ¼ãƒ‰ãŒ <literal>READ</literal> ã‚‚ã—ãã¯ã€<literal>UPGRADE</literal>〠<literal>UPGRADE_NOWAIT</literal> ã ã£ãŸå ´åˆã€<literal>Session.lock()</literal> ã¯ã€ãƒãƒ¼ã‚¸ãƒ§ãƒ³ç•ªå·ã®ãƒã‚§ãƒƒã‚¯ã‚’実施ã—ã¾ã™ã€‚ （<literal>UPGRADE</literal> ã‚‚ã—ã㯠<literal>UPGRADE_NOWAIT</literal> ã®å ´åˆã€ <literal>SELECT ... FOR UPDATE</literal> ãŒä½¿ã‚ã‚Œã¾ã™ã€‚）"
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr "データベースãŒè¦æ±‚ã•ã‚ŒãŸãƒãƒƒã‚¯ãƒ¢ãƒ¼ãƒ‰ã‚’サãƒãƒ¼ãƒˆã—ã¦ã„ãªã„å ´åˆã€ Hibernateã¯ï¼ˆä¾‹å¤–を投ã’る代ã‚ã‚Šã«ã€ï¼‰é©åˆ‡ãªä»£ã‚ã‚Šã®ãƒ¢ãƒ¼ãƒ‰ã‚’使ã„ã¾ã™ã€‚ ã“ã‚Œã¯ã€ã‚¢ãƒ—リケーションãŒãƒãƒ¼ã‚¿ãƒ–ルã§ã‚ã‚‹ã“ã¨ã‚’ä¿è¨¼ã—ã¾ã™ã€‚"
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr "コãƒã‚¯ã‚·ãƒ§ãƒ³é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰"
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr "Hibernateã®ãƒ¬ã‚¬ã‚·ãƒ¼ï¼ˆ2.x）ã®JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ç®¡ç†ã«é–¢ã™ã‚‹æŒ¯ã‚‹èˆžã„ã¯ã€ 最åˆã«å¿…è¦ã¨ã—ãŸéš›ã« <literal>Session</literal> ãŒã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å¾—ã‚‹ã¨ã„ã†ã‚‚ã®ã§ã—ãŸã€‚ ãã—ã¦ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ãŒé–‰ã˜ã‚‰ã‚Œã‚‹ã¾ã§ã€ãã®ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’ä¿æŒã—ã¾ã—ãŸã€‚ Hibernate 3.xã¯ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ã«JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’ã©ã®ã‚ˆã†ã«åˆ¶å¾¡ã™ã‚‹ã‹ã‚’ä¼ãˆã‚‹ コãƒã‚¯ã‚·ãƒ§ãƒ³é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰ã¨ã„ã†æ¦‚念を導入ã—ã¾ã—ãŸã€‚ 以é™ã®è°è«–ã¯ã€æ§‹æˆã•ã‚ŒãŸ <literal>ConnectionProvider</literal> を通ã—ã¦æä¾›ã•ã‚Œã‚‹ コãƒã‚¯ã‚·ãƒ§ãƒ³ã«é©åˆ‡ã§ã‚ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ç•°ãªã‚‹é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰ã¯ã€<literal>org.hibernate.ConnectionReleaseMode</literal> 㫠列挙ã•ã‚ŒãŸå€¤ã«ã‚ˆã‚Šç¢ºèªã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr "<literal>ON_CLOSE</literal> - 本質的ã«ä¸Šè¨˜ã§è¿°ã¹ãŸãƒ¬ã‚¬ã‚·ãƒ¼ã®æŒ¯ã‚‹èˆžã„ã§ã™ã€‚ Hibernateセッションã¯æœ€åˆã«JDBCアクセスを実行ã™ã‚‹å¿…è¦ãŒã‚ã‚‹éš›ã«ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’å¾—ã¾ã™ã€‚ ãã—ã¦ã€ã‚»ãƒƒã‚·ãƒ§ãƒ³ãŒé–‰ã˜ã‚‰ã‚Œã‚‹ã¾ã§ã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’ä¿æŒã—ã¾ã™ã€‚"
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr "<literal>AFTER_TRANSACTION</literal> - <literal>org.hibernate.Transaction</literal> ãŒå®Œäº†ã—ãŸå¾Œã€ コãƒã‚¯ã‚·ãƒ§ãƒ³ã‚’開放ã—ã¾ã™ã€‚"
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr "<literal>AFTER_STATEMENT</literal> （ç©æ¥µçš„ãªé–‹æ”¾ã¨ã‚‚呼ã°ã‚Œã‚‹ï¼‰ - ã™ã¹ã¦ã®ã‚¹ãƒ†ãƒ¼ãƒˆãƒ¡ãƒ³ãƒˆãŒãã‚Œãžã‚Œå®Ÿè¡Œã•ã‚ŒãŸå¾Œã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãŒé–‹æ”¾ã•ã‚Œã¾ã™ã€‚ ステートメントãŒã‚»ãƒƒã‚·ãƒ§ãƒ³ã«é–¢é€£ã™ã‚‹ãƒªã‚½ãƒ¼ã‚¹ã‚’é–‹ã„ãŸã¾ã¾ã«ã™ã‚‹å ´åˆã¯ã€ ã“ã®ç©æ¥µçš„ãªé–‹æ”¾ã¯ã‚¹ã‚ップã•ã‚Œã¾ã™ã€‚ 今ã®ã¨ã“ã‚ã€ã“ã‚ŒãŒèµ·ã“ã‚‹ã®ã¯ <literal>org.hibernate.ScrollableResults</literal> ãŒä½¿ã‚ã‚Œã‚‹å ´åˆã®ã¿ã§ã™ã€‚"
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr "コンフィグレーションパラメータ㮠<literal>hibernate.connection.release_mode</literal> ã¯ã€ä½¿ç”¨ã™ã‚‹é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰ã‚’指定ã™ã‚‹ãŸã‚ã«ä½¿ã„ã¾ã™ã€‚ 指定ã§ãる値ã¯æ¬¡ã®é€šã‚Šã§ã™ã€‚"
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr "<literal>auto</literal> （デフォルト） - ã“れをé¸æŠžã™ã‚‹ã¨ <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> メソッドã«ã‚ˆã£ã¦è¿”ã•ã‚Œã‚‹é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰ã«å§”è²ã•ã‚Œã¾ã™ã€‚ ã“ã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ã€ JTATransactionFactoryã«ã¯ConnectionReleaseMode.AFTER_STATEMENTã‚’è¿”ã—〠JDBCTransactionFactoryã«ã¯ConnectionReleaseMode.AFTER_TRANSACTIONã‚’è¿”ã—ã¾ã™ã€‚ ã“ã®ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆã®æŒ¯ã‚‹èˆžã„を変ãˆã¦ã†ã¾ãã„ã£ãŸè©¦ã—ãŒã‚ã‚Šã¾ã›ã‚“。 ãã‚Œã¯ã€ã“ã®è¨å®šå€¤ãŒåŽŸå› ã§èµ·ã“る障害ã¯ã€ ユーザコードã®ä¸ã§ãƒã‚°ã‚„é–“é•ã£ãŸæ¡ä»¶ã«ãªã‚Šã‚„ã™ã„ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr "<literal>on_close</literal> - ConnectionReleaseMode.ON_CLOSEを使ã„ã¾ã™ã€‚ ã“ã®è¨å®šã¯å¾Œæ–¹äº’æ›ã®ãŸã‚ã«æ®‹ã•ã‚Œã¦ã„ã¾ã™ãŒã€ä½¿ã‚ãªã„ã“ã¨ã‚’å¼·ã勧ã‚ã¾ã™ã€‚"
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr "<literal>after_transaction</literal> - ConnectionReleaseMode.AFTER_TRANSACTIONを使ã„ã¾ã™ã€‚ ã“ã®è¨å®šã¯JTA環境ã®ä¸ã§ã¯ä½¿ã†ã¹ãã§ã¯ã‚ã‚Šã¾ã›ã‚“。 ConnectionReleaseMode.AFTER_TRANSACTIONを指定ã—ã€è‡ªå‹•ã‚³ãƒŸãƒƒãƒˆãƒ¢ãƒ¼ãƒ‰ã®ä¸ã§ã¯ã€ 開放モードãŒAFTER_STATEMENTã§ã‚ã‚‹ã‹ã®ã‚ˆã†ã«ã€ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ã¯é–‹æ”¾ã•ã‚Œã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1153
+msgid "appended paragraph 1"
+msgstr "<literal>after_statement</literal> - ConnectionReleaseMode.AFTER_STATEMENTを使ã„ã¾ã™ã€‚ ã•ã‚‰ã«ã€è¨å®šã•ã‚ŒãŸ <literal>ConnectionProvider</literal> ã¯ã€ ã“ã®è¨å®š (<literal>supportsAggressiveRelease()</literal>) をサãƒãƒ¼ãƒˆã™ã‚‹ã‹ã©ã†ã‹ を調ã¹ã‚‹ãŸã‚ã«ä½¿ç”¨ã—ã¾ã™ã€‚ ã‚‚ã—ãã†ã§ãªã„å ´åˆã€é–‹æ”¾ãƒ¢ãƒ¼ãƒ‰ã¯ConnectionReleaseMode.AFTER_TRANSACTION ã«ãƒªã‚»ãƒƒãƒˆã•ã‚Œã¾ã™ã€‚ ã“ã®è¨å®šã¯æ¬¡ã®ç’°å¢ƒã§ã®ã¿å®‰å…¨ã§ã™ã€‚ ãã‚Œã¯ã€<literal>ConnectionProvider.getConnection()</literal> を呼ã³å‡ºã™ãŸã³ã« 基盤ã¨ãªã‚‹JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãŒåŒã˜ã‚‚ã®ã‚’å–å¾—ã§ãã‚‹ã‹ã€ åŒã˜ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãŒå¾—られるã“ã¨ãŒå•é¡Œã¨ãªã‚‰ãªã„自動コミット環境ã®ä¸ã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,2432 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr "Hibernateã®å°Žå…¥"
+
+#: index.docbook:10
+msgid "Preface"
+msgstr "<title>å‰æ›¸ã</title>"
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr "ã“ã®ç« ã¯Hibernateã‚’åˆã‚ã¦ä½¿ã†ãƒ¦ãƒ¼ã‚¶å‘ã‘ã®å…¥é–€çš„ãªãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã§ã™ã€‚ インメモリデータベースを使ã†ç°¡å˜ãªã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ã‚¢ãƒ—リケーションã‹ã‚‰å§‹ã‚〠一æ©ä¸€æ©ã‚ã‹ã‚Šã‚„ã™ã„ã‚„ã‚Šæ–¹ã§é–‹ç™ºã‚’進ã‚ã¾ã™ã€‚"
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr "ã“ã®ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã¯Hibernateã‚’åˆã‚ã¦ä½¿ã†ãƒ¦ãƒ¼ã‚¶ã‚’想定ã—ã¦ã„ã¾ã™ãŒã€ ç†è§£ã™ã‚‹ã«ã¯Javaã¨SQLã«ã¤ã„ã¦ã®çŸ¥è˜ãŒå¿…è¦ã§ã™ã€‚ ã“ã‚Œã¯Michael Gloeglã®æ‰‹ã«ã‚ˆã‚‹ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã‚’下敷ãã«ã—ã¦ã„ã¾ã™ãŒã€ ã“ã“ã§ã‚µãƒ¼ãƒ‰ãƒ‘ーティライブラリã¨è¨€ã£ã¦ã„ã‚‹ã®ã¯ã€JDK 1.4ã¨5.0用ã®ã‚‚ã®ã§ã™ã€‚ JDK 1.3を利用ã™ã‚‹ã®ã§ã‚ã‚Œã°ä»–ã®ãƒ©ã‚¤ãƒ–ラリãŒå¿…è¦ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。"
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã®ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã¯Hibernateディストリビューション㮠<literal>doc/reference/tutorial/</literal> ã«ã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr "パート1 - åˆã‚ã¦ã®Hibernateアプリケーション"
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr "最åˆã«ã‚³ãƒ³ã‚½ãƒ¼ãƒ«ãƒ™ãƒ¼ã‚¹ã®ç°¡å˜ãªHibernateアプリケーションを作æˆã—ã¾ã™ã€‚ Javaデータベース（HSQL DB）を利用ã™ã‚‹ã®ã§ã€ データベースサーãƒã‚’インストールã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr "ä»®ã«å°ã•ãªãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¢ãƒ—リケーションãŒå¿…è¦ã ã¨ã—ã¾ã—ょã†ã€‚ ãã®ã‚¢ãƒ—リケーションã«ã¯å‡ºå¸ã—ãŸã„イベントã¨ã€ ãã®ã‚¤ãƒ™ãƒ³ãƒˆã®ãƒ›ã‚¹ãƒˆã«ã¤ã„ã¦ã®æƒ…å ±ã‚’æ ¼ç´ã™ã‚‹ã‚‚ã®ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr "ã¾ãšæœ€åˆã«ã™ã‚‹ã“ã¨ã¯é–‹ç™ºç”¨ã®ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’セットアップã—ã¦ã€ å¿…è¦ã¨ãªã‚‹ã™ã¹ã¦ã®Javaライブラリをé…ç½®ã™ã‚‹ã“ã¨ã§ã™ã€‚ Hibernateウェブサイトã‹ã‚‰Hibernateディストリビューションをダウンãƒãƒ¼ãƒ‰ã—ã¦ãã ã•ã„。 ファイルを解å‡ã—㦠<literal>/lib</literal> ã«ã‚ã‚‹å¿…è¦ãªãƒ©ã‚¤ãƒ–ラリã®ã™ã¹ã¦ã‚’〠新ã—ã„開発用ディレクトリ㮠<literal>/lib</literal> ディレクトリã«é…ç½®ã—ã¦ãã ã•ã„。 ã“ã®ã‚ˆã†ã«ãªã£ã¦ã„ã‚‹ã¯ãšã§ã™ï¼š"
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr ""
+ "<![CDATA[.
+\n"
+ "+lib
+\n"
+ " antlr.jar
+\n"
+ " cglib.jar
+\n"
+ " asm.jar
+\n"
+ " asm-attrs.jars
+\n"
+ " commons-collections.jar
+\n"
+ " commons-logging.jar
+\n"
+ " hibernate3.jar
+\n"
+ " jta.jar
+\n"
+ " dom4j.jar
+\n"
+ " log4j.jar ]]>"
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr "ã“れ㌠<emphasis>本ドã‚ュメント執ç†æ™‚点ã§ã®</emphasis> Hibernateã®å¿…è¦æœ€ä½Žé™ã®ãƒ©ã‚¤ãƒ–ラリã§ã™ （メインアーカイブã®hibernate3.jarもコピーã—ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„）。 Hibernateã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã«ã‚ˆã£ã¦ã¯ã•ã‚‰ã«å¿…è¦ãªãƒ©ã‚¤ãƒ–ラリやã€ä¸è¦ãªãƒ©ã‚¤ãƒ–ラリãŒã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 Hibernateディストリビューション㮠<literal>lib/</literal> ディレクトリã«ã‚ã‚‹ <literal>README.txt</literal> ファイルを見ã¦ãã ã•ã„。 å¿…é ˆã¾ãŸã¯ã‚ªãƒ—ションã®ã‚µãƒ¼ãƒ‰ãƒ‘ーティライブラリã«ã¤ã„ã¦ã®æƒ…å ±ã‚’è¼‰ã›ã¦ã„ã¾ã™ （実際Log4jã¯å¿…é ˆã§ã¯ã‚ã‚Šã¾ã›ã‚“ãŒã€å¤šãã®é–‹ç™ºè€…ãŒå¥½ã‚“ã§ã„ã¾ã™ï¼‰ã€‚"
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr "次ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«æ ¼ç´ã™ã‚‹ã‚¤ãƒ™ãƒ³ãƒˆã‚’表ã™ã‚¯ãƒ©ã‚¹ã‚’作æˆã—ã¾ã™ã€‚"
+
+#: index.docbook:68
+msgid "The first class"
+msgstr "最åˆã®ã‚¯ãƒ©ã‚¹"
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr "最åˆã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã¯ã€ãƒ—ãƒãƒ‘ティをã„ãã¤ã‹æŒã¤ã‚·ãƒ³ãƒ—ルãªJavaBeanã§ã™ï¼š"
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;
+\n"
+ "
+\n"
+ "import java.util.Date;
+\n"
+ "
+\n"
+ "public class Event {
+\n"
+ " private Long id;
+\n"
+ "
+\n"
+ " private String title;
+\n"
+ " private Date date;
+\n"
+ "
+\n"
+ " public Event() {}
+\n"
+ "
+\n"
+ " public Long getId() {
+\n"
+ " return id;
+\n"
+ " }
+\n"
+ "
+\n"
+ " private void setId(Long id) {
+\n"
+ " this.id = id;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public Date getDate() {
+\n"
+ " return date;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void setDate(Date date) {
+\n"
+ " this.date = date;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public String getTitle() {
+\n"
+ " return title;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void setTitle(String title) {
+\n"
+ " this.title = title;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr "ã”覧ã®ã¨ãŠã‚Šã€ã“ã®ã‚¯ãƒ©ã‚¹ã¯ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ãŒprivateã®å¯è¦–性をæŒã£ã¦ã„ã‚‹ã®ã¨åŒæ™‚ã«ã€ JavaBean標準ã®ã‚²ãƒƒã‚¿ãƒ¼ã€ã‚»ãƒƒã‚¿ãƒ¼ãƒ¡ã‚½ãƒƒãƒ‰ã®å‘½åè¦ç´„ã«å¾“ã£ã¦ã„ã¾ã™ã€‚ ã“ã®ã‚ˆã†ãªè¨è¨ˆã¯æŽ¨å¥¨ã•ã‚Œã¦ã„ã¾ã™ãŒå¿…é ˆã§ã¯ã‚ã‚Šã¾ã›ã‚“。 アクセサメソッドをè¨ã‘ã‚‹ã®ã¯ãƒªãƒ•ã‚¡ã‚¯ã‚¿ãƒªãƒ³ã‚°ã‚’考ãˆãŸé ‘å¥æ€§ã®ãŸã‚ã§ã€ Hibernateã¯ãƒ•ã‚£ãƒ¼ãƒ«ãƒ‰ã«ç›´æŽ¥ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚ 引数ã®ãªã„コンストラクタã¯ã€ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã§ã“ã®ã‚¯ãƒ©ã‚¹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’作æˆã™ã‚‹ãŸã‚ã« å¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr "<literal>id</literal> プãƒãƒ‘ティã¯ã€ã‚る特定ã®ã‚¤ãƒ™ãƒ³ãƒˆã«å¯¾ã™ã‚‹ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åã®å€¤ã‚’ä¿æŒã—ã¾ã™ã€‚ Hibernateã®å®Œå…¨ãªæ©Ÿèƒ½ã‚’使ã„ãŸã‘ã‚Œã°ã€ã™ã¹ã¦ã®æ°¸ç¶šã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ （ãã‚Œã»ã©é‡è¦ã§ã¯ãªã„ä¾å˜ã‚¯ãƒ©ã‚¹ã¨ã„ã†ã‚‚ã®ã‚‚ã‚ã‚Šã¾ã™ï¼‰ ã«ã“ã®ã‚ˆã†ãªè˜åˆ¥åプãƒãƒ‘ティãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚ 事実上ã»ã¨ã‚“ã©ã®ã‚¢ãƒ—リケーション（特ã«webアプリケーション）ã§ã¯ã€ è˜åˆ¥åã§ã‚ªãƒ–ジェクトを区別ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ãŸã‚ã€ã“ã‚Œã¯åˆ¶é™ã¨ã„ã†ã‚ˆã‚Šã‚‚特徴ã§ã‚ã‚‹ã¨è€ƒãˆã‚‹ã¹ãã§ã™ã€‚ ã—ã‹ã—通常オブジェクトã®IDã‚’æ“作ã™ã‚‹ã‚ˆã†ãªã“ã¨ã¯ã—ã¾ã›ã‚“。 ãã®ãŸã‚セッターメソッドã¯privateã«ã™ã‚‹ã¹ãã§ã™ã€‚ Hibernateã ã‘ãŒã‚ªãƒ–ジェクトãŒã‚»ãƒ¼ãƒ–ã•ã‚ŒãŸã¨ãã«è˜åˆ¥åã¸å€¤ã‚’代入ã—ã¾ã™ã€‚ HibernateãŒï¼ˆpublic, private, protected）フィールドã«ç›´æŽ¥ã‚¢ã‚¯ã‚»ã‚¹ã§ãã‚‹ã®ã!
¨åŒæ§˜ã«ã€ public, private, protectedã®ã‚¢ã‚¯ã‚»ã‚µãƒ¡ã‚½ãƒƒãƒ‰ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã‚‹ã¨ã„ã†ã“ã¨ãŒã‚ã‹ã‚‹ã§ã—ょã†ã€‚ é¸æŠžã¯ã‚ãªãŸã«ä»»ã•ã‚Œã¦ã„ã‚‹ã®ã§ã€ã‚ãªãŸã®ã‚¢ãƒ—リケーションã®è¨è¨ˆã«åˆã‚ã›ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr "引数ã®ãªã„コンストラクタã¯ã™ã¹ã¦ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã«å¿…é ˆã§ã™ã€‚ ã“ã‚Œã¯HibernateãŒJavaã®ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã£ã¦ã€ã‚ªãƒ–ジェクトを作æˆã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ãŸã‚ã§ã™ã€‚ コンストラクタをprivateã«ã™ã‚‹ã“ã¨ã¯å¯èƒ½ã§ã™ãŒã€ 実行時ã®ãƒ—ãƒã‚シ生æˆã¨ã€ãƒã‚¤ãƒˆã‚³ãƒ¼ãƒ‰æ“作ãªã—ã®åŠ¹çŽ‡çš„ãªãƒ‡ãƒ¼ã‚¿ã®æŠ½å‡ºã«ã¯ã€ packageå¯è¦–性ãŒå¿…è¦ã§ã™ã€‚"
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr "開発フォルダ㮠<literal>src</literal> ã¨ã„ã†ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã®é©åˆ‡ãªãƒ‘ッケージã«ã€ ã“ã®Javaソースファイルをé…ç½®ã—ã¦ãã ã•ã„。 ã“ã®æ™‚点ã§ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã£ã¦ã„ã‚‹ã¯ãšã§ã™ï¼š"
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr ""
+ "<![CDATA[.
+\n"
+ "+lib
+\n"
+ " <Hibernate and third-party libraries>
+\n"
+ "+src
+\n"
+ " +events
+\n"
+ " Event.java]]>"
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr "次ã®ã‚¹ãƒ†ãƒƒãƒ—ã§ã¯ã€Hibernateã«ã“ã®æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®æƒ…å ±ã‚’æ•™ãˆã¾ã™ã€‚"
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr "マッピングファイル"
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr "Hibernateã¯ã€ã©ã®ã‚ˆã†ã«æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ã‚ªãƒ–ジェクトをãƒãƒ¼ãƒ‰ã—æ ¼ç´ã™ã‚Œã°ã‚ˆã„ã‹ã‚’知る必è¦ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã“ã§HibernateマッピングファイルãŒç™»å ´ã—ã¾ã™ã€‚ マッピングファイルã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹å†…ã®ã©ã®ãƒ†ãƒ¼ãƒ–ルã«ã‚¢ã‚¯ã‚»ã‚¹ã—ãªã‘ã‚Œã°ãªã‚‰ãªã„ã‹ã€ ãã®ãƒ†ãƒ¼ãƒ–ルã®ã©ã®ã‚«ãƒ©ãƒ を使ã†ã¹ãã‹ã‚’ã€Hibernateã«æ•™ãˆã¾ã™ã€‚"
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr "マッピングファイルã®åŸºæœ¬çš„ãªæ§‹é€ ã¯ã“ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ï¼š"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>
+\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">
+\n"
+ "
+\n"
+ "<hibernate-mapping>
+\n"
+ "[...]
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr "Hibernate DTDãŒéžå¸¸ã«æ´—ç·´ã•ã‚Œã¦ã„ã‚‹ã“ã¨ã«æ³¨ç›®ã—ã¦ãã ã•ã„。 ã“ã®DTDã¯ã€ã‚¨ãƒ‡ã‚£ã‚¿ã‚„IDEã§ã®XMLマッピングè¦ç´ ã¨å±žæ€§ã®ã‚ªãƒ¼ãƒˆã‚³ãƒ³ãƒ—リーション機能ã«åˆ©ç”¨ã§ãã¾ã™ã€‚ ã¾ãŸDTDファイルをテã‚ストエディタã§é–‹ã‘ã¦ã¿ã¦ãã ã•ã„。 ã¨ã„ã†ã®ã‚‚ã€ã™ã¹ã¦ã®è¦ç´ ã¨å±žæ€§ã‚’概観ã—〠コメントやデフォルトã®å€¤ã‚’見るã«ã¯ä¸€ç•ªç°¡å˜ãªæ–¹æ³•ã ã‹ã‚‰ã§ã™ã€‚ Hibernateã¯ã€webã‹ã‚‰DTDファイルをãƒãƒ¼ãƒ‰ã›ãšã«ã€ ã¾ãšã‚¢ãƒ—リケーションã®ã‚¯ãƒ©ã‚¹ãƒ‘スã‹ã‚‰ã“れを探ã—出ãã†ã¨ã™ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 DTDファイルã¯Hibernateディストリビューション㮠<literal>src/</literal> ディレクトリã¨åŒæ§˜ã€<literal>hibernate3.jar</literal> ã«ã‚‚å«ã¾ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr "以é™ã®ä¾‹ã§ã¯ã‚³ãƒ¼ãƒ‰ã‚’çŸãã™ã‚‹ãŸã‚ã«DTD宣言をçœç•¥ã—ã¾ã™ã€‚ 当然ã§ã™ãŒã“ã‚Œã¯ã‚ªãƒ—ションã§ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr "2ã¤ã® <literal>hibernate-mapping</literal> ã‚¿ã‚°ã®é–“ã« <literal>class</literal> è¦ç´ ã‚’å«ã‚ã¦ãã ã•ã„。 ã™ã¹ã¦ã®æ°¸ç¶šã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã‚¯ãƒ©ã‚¹ï¼ˆå¿µã‚’押ã—ã¾ã™ãŒã€ ファーストクラスã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã§ã¯ãªã„ä¾å˜ã‚¯ãƒ©ã‚¹ã¨ã„ã†ã‚‚ã®ãŒå¾Œã»ã©ç™»å ´ã—ã¾ã™ï¼‰ ã¯SQLデータベース内ã®ãƒ†ãƒ¼ãƒ–ルã¸ã®ã“ã®ã‚ˆã†ãªãƒžãƒƒãƒ”ングを必è¦ã¨ã—ã¾ã™ã€‚"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">
+\n"
+ "
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr "ã“ã‚Œã¾ã§ç§ãŸã¡ã¯ã€<literal>Event</literal> クラスã®ã‚ªãƒ–ジェクトを <literal>EVENTS</literal> テーブルã«å¯¾ã—ã¦ã€ã©ã®ã‚ˆã†ã«æ°¸ç¶šåŒ–ã—ãŸã‚Šãƒãƒ¼ãƒ‰ã—ãŸã‚Šã™ã‚‹ã®ã‹ã‚’ Hibernateã«æ•™ãˆã¦ãã¾ã—ãŸã€‚ãã—ã¦å€‹ã€…ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ãƒ†ãƒ¼ãƒ–ルã®è¡Œã¨ã—ã¦è¡¨ç¾ã•ã‚Œã¾ã™ã€‚ ãã‚Œã§ã¯å¼•ã続ãテーブルã®ä¸»ã‚ーã«å¯¾ã™ã‚‹ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªè˜åˆ¥åプãƒãƒ‘ティをマッピングã—ã¦ã„ãã¾ã™ã€‚ ã•ã‚‰ã«ã€ã“ã®è˜åˆ¥åã®æ‰±ã„ã«æ°—を使ã„ãŸããªã‹ã£ãŸã®ã¨åŒæ§˜ã«ã€ 代ç†ã®ä¸»ã‚ーカラムã«å¯¾ã™ã‚‹Hibernateã®è˜åˆ¥å生æˆæˆ¦ç•¥ã‚’è¨å®šã—ã¾ã™ã€‚"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">
+\n"
+ " <id name=\"id\" column=\"EVENT_ID\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr "<literal>id</literal> è¦ç´ ã¯è˜åˆ¥åプãƒãƒ‘ティã®å®£è¨€ã§ã‚り〠<literal>name=\"id\"</literal> ã§Javaプãƒãƒ‘ティã®åå‰ã‚’宣言ã—ã¾ã™ã€‚ Hibernateã¯ã“ã®ãƒ—ãƒãƒ‘ティã¸ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ãŸã‚ã«ã‚²ãƒƒã‚¿ãƒ¼ã€ã‚»ãƒƒã‚¿ãƒ¼ãƒ¡ã‚½ãƒƒãƒ‰ã‚’使ã„ã¾ã™ã€‚ カラム属性ã§ã¯ <literal>EVENTS</literal> テーブルã®ã©ã®ã‚«ãƒ©ãƒ を主ã‚ーã¨ã—ã¦ä½¿ã†ã®ã‹ã‚’ Hibernateã«æ•™ãˆã¾ã™ã€‚ 入れåã«ãªã£ã¦ã„ã‚‹ <literal>generator</literal> è¦ç´ ã¯ã€è˜åˆ¥åを生æˆã™ã‚‹æ™‚ã®æˆ¦ç•¥ã‚’指定ã—ã¾ã™ã€‚ （ã“ã®ä¾‹ã§ã¯ <literal>native</literal> を用ã„ã¾ã—ãŸï¼‰ã€‚ ã“ã®è¦ç´ ã¯ã€è¨å®šã—ãŸãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ï¼ˆdialect）ã«å¯¾ã™ã‚‹æœ€è‰¯ãªè˜åˆ¥å生æˆæˆ¦ç•¥ã‚’é¸å®šã™ã‚‹ã‚‚ã®ã§ã™ã€‚ Hibernateã¯ã€ã‚¢ãƒ—リケーションã§å€¤ã‚’割り当ã¦ã‚‹æˆ¦ç•¥ï¼ˆã‚‚ã—ãã¯ç‹¬è‡ªã«æ‹¡å¼µã—ãŸæˆ¦ç•¥ï¼‰ã¨åŒæ§˜ã«ã€ ã‚°ãƒãƒ¼ãƒãƒ«ã«ãƒ¦ãƒ‹ãƒ¼ã‚¯ãªå€¤ã‚’データベースã«ç”Ÿæˆã•ã›ã‚‹æˆ¦ç•¥ã‚‚サãƒãƒ¼ã!
ƒˆã—ã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr "最後ã«ã‚¯ãƒ©ã‚¹ã®æ°¸ç¶šãƒ—ãƒãƒ‘ティã®å®£è¨€ã‚’マッピングファイルã«å«ã‚ã¾ã™ã€‚ デフォルトã§ã¯ã€ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティã¯æ°¸ç¶šã¨è¦‹ãªã•ã‚Œã¾ã›ã‚“："
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[
+\n"
+ "<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">
+\n"
+ " <id name=\"id\" column=\"EVENT_ID\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>
+\n"
+ " <property name=\"title\"/>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr "<literal>id</literal> è¦ç´ ã®å ´åˆã¨åŒæ§˜ã«ã€ <literal>property</literal> è¦ç´ ã® <literal>name</literal> 属性ã§ã€ã©ã®ã‚²ãƒƒã‚¿ãƒ¼ã¨ã‚»ãƒƒã‚¿ãƒ¼ãƒ¡ã‚½ãƒƒãƒ‰ã‚’使ã†ã¹ãã‹ã‚’Hibernateã«æ•™ãˆã¾ã™ã€‚ ã“ã®ä¾‹ã§ã¯ã€Hibernate㯠<literal>getDate()/setDate()</literal> 㨠<literal>getTitle()/setTitle()</literal> ã‚’ 探ã—ã¾ã™ã€‚"
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr "ãªãœ <literal>date</literal> プãƒãƒ‘ティã®ãƒžãƒƒãƒ”ングã«ã¯ <literal>column</literal> 属性ãŒã‚ã‚Šã€<literal>title</literal> プãƒãƒ‘ティã«ã¯ãªã„ã®ã§ã—ょã†ã‹ï¼Ÿ <literal>column</literal> 属性ãŒãªã‘ã‚Œã°ã€Hibernateã¯ãƒ—ãƒãƒ‘ティåをカラムåã¨ã—ã¦ä½¿ã„ã¾ã™ã€‚ ã“れ㯠<literal>title</literal> ã§ã¯ä¸Šæ‰‹ãè¡Œãã¾ã™ã€‚ ã—ã‹ã— <literal>date</literal> ã¯ã»ã¨ã‚“ã©ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã§äºˆç´„語ãªã®ã§ã€ é•ã†åå‰ã§ãƒžãƒƒãƒ”ングã—ãŸæ–¹ãŒã‚ˆã„ã®ã§ã™ã€‚"
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr "次ã«èˆˆå‘³æ·±ã„ã®ã¯ <literal>title</literal> マッピング㌠<literal>type</literal> å±žæ€§ã‚’ã‚‚æ¬ ã„ã¦ã„る点ã§ã™ã€‚ マッピングファイルã§å®£è¨€ã—ã¦ä½¿ã†typeã¯ã€ãŠã‚ã‹ã‚Šã‹ã‚‚ã—ã‚Œã¾ã›ã‚“ãŒJavaã®ãƒ‡ãƒ¼ã‚¿åž‹ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 SQLデータベースã®åž‹ã§ã‚‚ã‚ã‚Šã¾ã›ã‚“。 ã“れ㯠<emphasis>Hibernateマッピング型</emphasis> ã¨å‘¼ã°ã‚Œã‚‹ã€ Javaã‹ã‚‰SQLデータã®åž‹ã¸ã¾ãŸã¯SQLã‹ã‚‰Javaデータ型ã¸ç¿»è¨³ã™ã‚‹ã‚³ãƒ³ãƒãƒ¼ã‚¿ã§ã™ã€‚ ç¹°ã‚Šè¿”ã—ã«ãªã‚Šã¾ã™ãŒã€Hibernate㯠<literal>type</literal> 属性ãŒãƒžãƒƒãƒ”ングファイル内ã«ãªã‘ã‚Œã°ã€ æ£ã—ã„コンãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¨ãƒžãƒƒãƒ”ング型を自分ã§è§£æ±ºã—よã†ã¨ã—ã¾ã™ã€‚ （Javaクラスã®ãƒªãƒ•ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’使ã£ãŸï¼‰ã“ã®è‡ªå‹•æ¤œçŸ¥ã¯ã€ å ´åˆã«ã‚ˆã£ã¦ã¯ã‚ãªãŸãŒæœŸå¾…ã¾ãŸã¯å¿…è¦ã¨ã™ã‚‹ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã«ãªã‚‰ãªã„ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 <literal>date</literal> プãƒãƒ‘ティã®å ´åˆãŒ!
ãã†ã§ã—ãŸã€‚ Hibernateã¯ã“ã®ï¼ˆ <literal>java.util.Date</literal> ã®ï¼‰ãƒ—ãƒãƒ‘ティを SQLã® <literal>date</literal> , <literal>timestamp</literal> , <literal>time</literal> ã®ã†ã¡ã€ã©ã®ã‚«ãƒ©ãƒ ã«ãƒžãƒƒãƒ”ングã™ã‚‹ã¹ããªã®ã‹ã‚ã‹ã‚Šã¾ã›ã‚“。 <literal>timestamp</literal> コンãƒãƒ¼ã‚¿ã§ãƒ—ãƒãƒ‘ティをマッピングã™ã‚‹ã“ã¨ã«ã‚ˆã‚Šã€å®Œå…¨ãªæ—¥æ™‚ã‚’ä¿å˜ã—ã¾ã™ã€‚"
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr "ã“ã®ãƒžãƒƒãƒ”ングファイルã¯ã€<literal>Event.hbm.xml</literal> ã¨ã—㦠<literal>Event</literal> Javaクラスソースファイルã®ã™ã隣ã«ã‚»ãƒ¼ãƒ–ã™ã‚‹ã¹ãã§ã™ã€‚ マッピングファイルã®å‘½å方法ã¯ä»»æ„ã§ã™ãŒã€<literal>hbm.xml</literal> サフィックスãŒHibernateã®é–‹ç™ºè€…ã®ã‚³ãƒŸãƒ¥ãƒ‹ãƒ†ã‚£å†…ã§ã®ç¿’æ…£ã¨ãªã£ã¦ã„ã¾ã™ã€‚ ç¾åœ¨ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªæ§‹é€ ã¯ã“ã®ã‚ˆã†ã«ãªã£ã¦ã„ã‚‹ã¯ãšã§ã™ï¼š"
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr ""
+ "<![CDATA[.
+\n"
+ "+lib
+\n"
+ " <Hibernate and third-party libraries>
+\n"
+ "+src
+\n"
+ " +events
+\n"
+ " Event.java
+\n"
+ " Event.hbm.xml]]>"
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr "Hibernateã®ä¸»è¦ãªè¨å®šã‚’続ã‘ã¾ã™ã€‚"
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr "Hibernateã®è¨å®š"
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr "ã“ã“ã¾ã§ã§æ°¸ç¶šã‚¯ãƒ©ã‚¹ã¨ãƒžãƒƒãƒ”ングファイルãŒæƒã„ã¾ã—ãŸã€‚ã“ã‚Œã‹ã‚‰Hibernateã®è¨å®šã‚’è¡Œã„ã¾ã™ãŒã€ ãã®å‰ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒå¿…è¦ã§ã™ã€‚ HSQL DBã¯Javaベースã®ã‚¤ãƒ³ãƒ¡ãƒ¢ãƒªSQL DBMSã§ã‚ã‚Šã€HSQL DBウェブサイトã‹ã‚‰ãƒ€ã‚¦ãƒ³ãƒãƒ¼ãƒ‰ã§ãã¾ã™ã€‚ 実際ã«ã¯ãƒ€ã‚¦ãƒ³ãƒãƒ¼ãƒ‰ã—ãŸä¸ã® <literal>hsqldb.jar</literal> ã ã‘ãŒå¿…è¦ã§ã™ã€‚ ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚’開発フォルダ㮠<literal>lib/</literal> ディレクトリã«é…ç½®ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr "<literal>data</literal> ã¨ã„ã†ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‚’開発ディレクトリã®ãƒ«ãƒ¼ãƒˆã«ä½œæˆã—ã¦ãã ã•ã„。 HSQL DBã¯ã“ã“ã«ãƒ‡ãƒ¼ã‚¿ãƒ•ã‚¡ã‚¤ãƒ«ã‚’æ ¼ç´ã—ã¾ã™ã€‚ ã“ã®ãƒ‡ãƒ¼ã‚¿ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«ãŠã„㦠<literal>java -classpath lib/hsqldb.jar org.hsqldb.Server</literal> を実行ã—〠データベースを起動ã•ã›ã¦ãã ã•ã„。 動作ã®é–‹å§‹ã¨ã€TCP/IPソケットã®ãƒã‚¤ãƒ³ãƒ‰ãŒç¢ºèªã§ãã¾ã™ã€‚ 後ã»ã©ä½œæˆã™ã‚‹ã‚¢ãƒ—リケーションã¯ã“ã“ã«æŽ¥ç¶šã—ã¾ã™ã€‚ ã‚‚ã—ã“ã®ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ä¸ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’åˆæœŸåŒ–ã—ãŸã‘ã‚Œã°ã€ HSQL DBをシャットダウンã—ã¦ï¼ˆä½œæ¥ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã§ <literal>CTRL + C</literal> を押ã—ã¾ã™ï¼‰ <literal>data/</literal> ディレクトリ内ã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚’å…¨ã¦æ¶ˆåŽ»ã—ãŸå¾Œã€ HSQL DBã‚’å†èµ·å‹•ã—ã¾ã™ã€‚"
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr "Hibernateã¯ã‚¢ãƒ—リケーションã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«æŽ¥ç¶šã™ã‚‹å±¤ãªã®ã§ã€ コãƒã‚¯ã‚·ãƒ§ãƒ³ã®æƒ…å ±ãŒå¿…è¦ã«ãªã‚Šã¾ã™ã€‚ コãƒã‚¯ã‚·ãƒ§ãƒ³ã¯JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールを通ã˜ã¦è¡Œã‚ã‚Œã¾ã™ãŒã€ã“れもè¨å®šã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ Hibernateディストリビューションã«ã¯ã„ãã¤ã‹ã®ã‚ªãƒ¼ãƒ—ンソースã®JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールツールãŒå«ã¾ã‚Œã¦ã„ã¾ã™ãŒã€ ã“ã®ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã§ã¯Hibernateã«çµ„ã¿è¾¼ã¾ã‚ŒãŸã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールを使ã„ã¾ã™ã€‚ ã‚‚ã—製å“レベルã®å“質ã®ã‚µãƒ¼ãƒ‰ãƒ‘ーティJDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールソフトウェアを使ã„ãŸã‘ã‚Œã°ã€ クラスパスã«å¿…è¦ãªãƒ©ã‚¤ãƒ–ラリをコピーã—ã¦ã€ç•°ãªã‚‹ã‚³ãƒã‚¯ã‚·ãƒ§ãƒ³ãƒ—ールをè¨å®šã—ãªã‘れ㰠ãªã‚‰ãªã„ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr "Hibernateã®è¨å®šã§ã¯ã€å˜ç´”㪠<literal>hibernate.properties</literal> ファイル〠ãれより少ã—æ´—ç·´ã•ã‚Œã¦ã„ã‚‹ <literal>hibernate.cfg.xml</literal> ファイル〠ã¾ãŸã¯å®Œå…¨ã«ãƒ—ãƒã‚°ãƒ©ãƒ 上ã§ã‚»ãƒƒãƒˆã‚¢ãƒƒãƒ—ã™ã‚‹æ–¹æ³•ãŒåˆ©ç”¨ã§ãã¾ã™ã€‚ ã»ã¨ã‚“ã©ã®ãƒ¦ãƒ¼ã‚¶ãŒå¥½ã‚€ã®ã¯XMLè¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã§ã™ï¼š"
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>
+\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC
+\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"
+\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">
+\n"
+ "
+\n"
+ "<hibernate-configuration>
+\n"
+ "
+\n"
+ " <session-factory>
+\n"
+ "
+\n"
+ " <!-- Database connection settings -->
+\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>
+\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>
+\n"
+ " <property name=\"connection.username\">sa</property>
+\n"
+ " <property name=\"connection.password\"></property>
+\n"
+ "
+\n"
+ " <!-- JDBC connection pool (use the built-in) -->
+\n"
+ " <property name=\"connection.pool_size\">1</property>
+\n"
+ "
+\n"
+ " <!-- SQL dialect -->
+\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>
+\n"
+ "
+\n"
+ " <!-- Enable Hibernate's automatic session context management -->
+\n"
+ " <property name=\"current_session_context_class\">thread</property>
+\n"
+ "
+\n"
+ " <!-- Disable the second-level cache -->
+\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>
+\n"
+ "
+\n"
+ " <!-- Echo all executed SQL to stdout -->
+\n"
+ " <property name=\"show_sql\">true</property>
+\n"
+ "
+\n"
+ " <!-- Drop and re-create the database schema on startup -->
+\n"
+ " <property name=\"hbm2ddl.auto\">create</property>
+\n"
+ "
+\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>
+\n"
+ "
+\n"
+ " </session-factory>
+\n"
+ "
+\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr "ã“ã®XMLã®è¨å®šãŒç•°ãªã‚‹DTDを使ã†ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 特定ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚’å—ã‘æŒã¤ã‚°ãƒãƒ¼ãƒãƒ«ãƒ•ã‚¡ã‚¯ãƒˆãƒªã§ã‚ã‚‹Hibernateã® <literal>SessionFactory</literal> ã‚’è¨å®šã—ã¾ã™ã€‚ ã‚‚ã—複数ã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãŒã‚ã‚‹å ´åˆã«ã¯ã€ （スタートアップを簡å˜ã«ã™ã‚‹ãŸã‚）通常ã„ãã¤ã‹ã®è¨å®šãƒ•ã‚¡ã‚¤ãƒ«å†…ã§ã€ ã„ãã¤ã‹ã® <literal><session-factory></literal> を使ã†è¨å®šã«ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr "最åˆã®4ã¤ã® <literal>property</literal> è¦ç´ ã¯JDBCコãƒã‚¯ã‚·ãƒ§ãƒ³ã«å¿…è¦ãªè¨å®šã‚’å«ã‚“ã§ã„ã¾ã™ã€‚ dialectã¨ã„ã†åå‰ã® <literal>property</literal> è¦ç´ ã¯ã€HibernateãŒç”Ÿæˆã™ã‚‹ç‰¹å®šã®SQL方言を指定ã—ã¾ã™ã€‚ 永続的ãªã‚³ãƒ³ãƒ†ã‚ストã«å¯¾ã™ã‚‹Hibernateã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã®è‡ªå‹•ç®¡ç†ã¯ã€å¾Œã®ä¾‹ã§ã™ãã«ã‚ã‹ã‚‹ã‚ˆã†ã«ã€å½¹ã«ç«‹ã¤ã“ã¨ã§ã—ょã†ã€‚ <literal>hbm2ddl.auto</literal> オプションã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã®è‡ªå‹•ç”Ÿæˆã‚’onã«ã—ã¾ã™ã€‚ ã“ã‚Œã¯ç›´æŽ¥ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«å¯¾ã—ã¦ç”Ÿæˆã•ã‚Œã¾ã™ã€‚ 当然（configオプションを削除ã—ã¦ï¼‰offã«ã—ãŸã‚Šã€ <literal>SchemaExport</literal> ã¨ã„ã†Antタスクã®åŠ©ã‘を借りã¦ãƒ•ã‚¡ã‚¤ãƒ«ã«ãƒªãƒ€ã‚¤ãƒ¬ã‚¯ãƒˆã—ãŸã‚Šã§ãã¾ã™ã€‚ 最後ã«æ°¸ç¶šã‚¯ãƒ©ã‚¹ã®ãŸã‚ã®ãƒžãƒƒãƒ”ングファイルをè¨å®šã«è¿½åŠ ã—ã¾ã™ã€‚"
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr "ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚’ソースディレクトリã«ã‚³ãƒ”ーã—ã¦ãã ã•ã„。 ã™ã‚‹ã¨ã“ã‚Œã¯ã‚¯ãƒ©ã‚¹ãƒ‘スã®ãƒ«ãƒ¼ãƒˆã«ã‚ã‚‹ã“ã¨ã«ãªã‚Šã¾ã™ã€‚ Hibernateã¯ã€ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—時ã«ã‚¯ãƒ©ã‚¹ãƒ‘スã®ãƒ«ãƒ¼ãƒˆã§ <literal>hibernate.cfg.xml</literal> ã¨ã„ã†ãƒ•ã‚¡ã‚¤ãƒ«ã‚’自動的ã«æŽ¢ã—ã¾ã™ã€‚"
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr "Antã«ã‚ˆã‚‹ãƒ“ルド"
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr "ãã‚Œã§ã¯Antを使ã£ã¦ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã‚’ビルドã—ã¾ã—ょã†ã€‚ ãã‚Œã«ã¯AntãŒã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«ã•ã‚Œã¦ã„ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <ulink url=\"http://ant.apache.org/bindownload.cgi\">Antダウンãƒãƒ¼ãƒ‰ãƒšãƒ¼ã‚¸</ulink> ã‹ã‚‰ãƒ€ã‚¦ãƒ³ãƒãƒ¼ãƒ‰ã—ã¦ãã ã•ã„。 Antã®ã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«æ–¹æ³•ã¯ã“ã“ã§ã¯èª¬æ˜Žã—ã¾ã›ã‚“ã®ã§ã€ <ulink url=\"http://ant.apache.org/manual/index.html\">Antマニュアル</ulink> ã‚’å‚ç…§ã—ã¦ãã ã•ã„。 Antをインストールã™ã‚Œã°ã€ãƒ“ルドファイルã®ä½œæˆã‚’開始ã§ãã¾ã™ã€‚ ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã¯ <literal>build.xml</literal> ã¨å‘¼ã°ã‚Œã€é–‹ç™ºãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«ç›´æŽ¥é…ç½®ã—ã¾ã™ã€‚"
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr "基本的ãªãƒ“ルドファイルã¯ã“ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ï¼š"
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">
+\n"
+ "
+\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>
+\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>
+\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>
+\n"
+ "
+\n"
+ " <path id=\"libraries\">
+\n"
+ " <fileset dir=\"${librarydir}\">
+\n"
+ " <include name=\"*.jar\"/>
+\n"
+ " </fileset>
+\n"
+ " </path>
+\n"
+ "
+\n"
+ " <target name=\"clean\">
+\n"
+ " <delete dir=\"${targetdir}\"/>
+\n"
+ " <mkdir dir=\"${targetdir}\"/>
+\n"
+ " </target>
+\n"
+ "
+\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">
+\n"
+ " <javac srcdir=\"${sourcedir}\"
+\n"
+ " destdir=\"${targetdir}\"
+\n"
+ " classpathref=\"libraries\"/>
+\n"
+ " </target>
+\n"
+ "
+\n"
+ " <target name=\"copy-resources\">
+\n"
+ " <copy todir=\"${targetdir}\">
+\n"
+ " <fileset dir=\"${sourcedir}\">
+\n"
+ " <exclude name=\"**/*.java\"/>
+\n"
+ " </fileset>
+\n"
+ " </copy>
+\n"
+ " </target>
+\n"
+ "
+\n"
+ "</project>]]>"
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr "ã“れ㯠<literal>.jar</literal> ã§çµ‚ã‚ã‚‹libディレクトリã®ã™ã¹ã¦ã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚’〠コンパイルã«ä½¿ç”¨ã™ã‚‹ã‚¯ãƒ©ã‚¹ãƒ‘スã«è¿½åŠ ã™ã‚‹ã“ã¨ã‚’Antã«æ•™ãˆã¾ã™ã€‚ ã¾ãŸã€Javaソースファイルã§ãªã„ã™ã¹ã¦ã®ãƒ•ã‚¡ã‚¤ãƒ«ã‚’ターゲットディレクトリã«ã‚³ãƒ”ーã™ã‚‹ã¨ã„ã†ã“ã¨ã§ã‚‚ã‚ã‚Šã¾ã™ã€‚ 例ãˆã°è¨å®šãƒ•ã‚¡ã‚¤ãƒ«ã‚„Hibernateマッピングファイルãªã©ã§ã™ã€‚ 今Antを実行ã™ã‚‹ã¨ã€ã“ã®ã‚ˆã†ãªå‡ºåŠ›ãŒã‚ã‚‹ã¯ãšã§ã™ï¼š"
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr ""
+ "<![CDATA[C:¥hibernateTutorial¥>ant
+\n"
+ "Buildfile: build.xml
+\n"
+ "
+\n"
+ "copy-resources:
+\n"
+ " [copy] Copying 2 files to C:¥hibernateTutorial¥bin
+\n"
+ "
+\n"
+ "compile:
+\n"
+ " [javac] Compiling 1 source file to C:¥hibernateTutorial¥bin
+\n"
+ "
+\n"
+ "BUILD SUCCESSFUL
+\n"
+ "Total time: 1 second ]]>"
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr "スタートアップã¨ãƒ˜ãƒ«ãƒ‘"
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr "ã•ã¦ <literal>Event</literal> オブジェクトをãƒãƒ¼ãƒ‰ã—ãŸã‚Šæ ¼ç´ã—ãŸã‚Šã™ã‚‹æº–å‚™ãŒã§ãã¾ã—ãŸã€‚ ã—ã‹ã—ã¾ãšã¯ã‚¤ãƒ³ãƒ•ãƒ©ã‚¹ãƒˆãƒ©ã‚¯ãƒãƒ£ã®ã‚³ãƒ¼ãƒ‰ã‚’書ã„ã¦ã€ã‚»ãƒƒãƒˆã‚¢ãƒƒãƒ—を完了ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ ã¾ãšã¯Hibernateをスタートアップã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 ã“ã®ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—ã«ã¯ã€ã‚°ãƒãƒ¼ãƒãƒ«ã® <literal>SessionFactory</literal> オブジェクトを生æˆã—ã¦ã€ ãれをアプリケーションã®ã‚³ãƒ¼ãƒ‰ã§ã‚¢ã‚¯ã‚»ã‚¹ã—ã‚„ã™ã„å ´æ‰€ã«æ ¼ç´ã™ã‚‹ã“ã¨ãŒå«ã¾ã‚Œã¾ã™ã€‚ <literal>SessionFactory</literal> ã¯æ–°ã—ã <literal>Session</literal> をオープンã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal>Session</literal> ã¯ã‚·ãƒ³ã‚°ãƒ«ã‚¹ãƒ¬ãƒƒãƒ‰ã®ä½œæ¥å˜ä½(Unit of Work)を表ç¾ã—ã¾ã™ã€‚ ãã‚Œã«å¯¾ã—<literal>SessionFactory</literal> ã¯ã‚¹ãƒ¬ãƒƒãƒ‰ã‚»ãƒ¼ãƒ•ã®ã‚°ãƒãƒ¼ãƒãƒ«ã‚ªãƒ–ジェクトã§ã‚り〠一度ã ã‘インスタンス化ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr "ã“ã“ã§ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—ã‚’è¡Œã„〠便利㫠<literal>SessionFactory</literal> ã¸ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ <literal>HibernateUtil</literal> ヘルパクラスを作æˆã—ã¾ã™ã€‚ 実装を見ã¦ã¿ã¾ã—ょã†ï¼š"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package util;
+\n"
+ "
+\n"
+ "import org.hibernate.*;
+\n"
+ "import org.hibernate.cfg.*;
+\n"
+ "
+\n"
+ "public class HibernateUtil {
+\n"
+ "
+\n"
+ " private static final SessionFactory sessionFactory;
+\n"
+ "
+\n"
+ " static {
+\n"
+ " try {
+\n"
+ " // Create the SessionFactory from hibernate.cfg.xml
+\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();
+\n"
+ " } catch (Throwable ex) {
+\n"
+ " // Make sure you log the exception, as it might be swallowed
+\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);
+\n"
+ " throw new ExceptionInInitializerError(ex);
+\n"
+ " }
+\n"
+ " }
+\n"
+ "
+\n"
+ " public static SessionFactory getSessionFactory() {
+\n"
+ " return sessionFactory;
+\n"
+ " }
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr "ã“ã®ã‚¯ãƒ©ã‚¹ã¯é™çš„åˆæœŸåŒ–ブãƒãƒƒã‚¯ï¼ˆã‚¯ãƒ©ã‚¹ãŒãƒãƒ¼ãƒ‰ã•ã‚Œã‚‹ã¨ãã«JVMã«ã‚ˆã£ã¦ä¸€åº¦ã ã‘呼ã°ã‚Œã‚‹ï¼‰ ã§ã‚°ãƒãƒ¼ãƒãƒ«ã® <literal>SessionFactory</literal> を生æˆã™ã‚‹ã ã‘ã§ã¯ãªã〠é™çš„シングルトンã®ä½¿ç”¨ã‚’éš è”½ã—ã¾ã™ã€‚ アプリケーションサーãƒãƒ¼ã®JNDIã‹ã‚‰ <literal>SessionFactory</literal> ã‚’ ルックアップã™ã‚‹ã®ã¨åŒæ§˜ã§ã™ã€‚"
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr "è¨å®šãƒ•ã‚¡ã‚¤ãƒ«å†…㧠<literal>SessionFactory</literal> ã«åå‰ã‚’与ãˆã‚‹ã¨ã€ Hibernate㯠<literal>SessionFactory</literal> 構築後ã«JNDIã«å¯¾ã—ãƒã‚¤ãƒ³ãƒ‰ã‚’è¡ŒãŠã†ã¨ã—ã¾ã™ã€‚ ã“ã®ã‚³ãƒ¼ãƒ‰ã‚’完全ã«æŽ’除ã™ã‚‹ãŸã‚ã«ã¯ã€ JMXデプãƒã‚¤ãƒ¡ãƒ³ãƒˆã‚’利用ã—㦠JMXを利用ã§ãるコンテナをインスタンス化ã—〠<literal>HibernateService</literal> ã‚’JNDIã¸ãƒã‚¤ãƒ³ãƒ‰ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ã“れらã®é«˜åº¦ãªã‚ªãƒ—ションã¯ã€Hibernateã®ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹ãƒ‰ã‚ュメントã§èª¬æ˜Žã•ã‚Œã¦ã„ã¾ã™ã€‚"
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr "<literal>HibernateUtil.java</literal> を開発ソースディレクトリã«ã‚ã‚‹ <literal>events</literal> パッケージ㮠隣ã«é…ç½®ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr ""
+ "<![CDATA[.
+\n"
+ "+lib
+\n"
+ " <Hibernate and third-party libraries>
+\n"
+ "+src
+\n"
+ " +events
+\n"
+ " Event.java
+\n"
+ " Event.hbm.xml
+\n"
+ " +util
+\n"
+ " HibernateUtil.java
+\n"
+ " hibernate.cfg.xml
+\n"
+ "+data
+\n"
+ "build.xml]]>"
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr "ã“ã‚Œã¯å•é¡Œãªãå†ã‚³ãƒ³ãƒ‘イルã§ãã‚‹ã¯ãšã§ã™ã€‚ 最後ã«ãƒã‚®ãƒ³ã‚°ã‚·ã‚¹ãƒ†ãƒ ã‚’è¨å®šã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ Hibernateã¯commons loggingを使ã†ãŸã‚ã€Log4jã¨JDK 1.4 loggingã®é¸æŠžã‚’ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã›ã‚“。 ã»ã¨ã‚“ã©ã®é–‹ç™ºè€…ãŒå¥½ã‚€ã®ã¯Log4jã§ã™ã€‚ Hibernateディストリビューション（ã®<literal>etc/</literal> ディレクトリ）ã‹ã‚‰ <literal>log4j.properties</literal> ã‚’ã‚ãªãŸã® <literal>src</literal> ディレクトリ内㮠<literal>hibernate.cfg.xml</literal> ã®éš£ã«ã‚³ãƒ”ーã—ã¦ãã ã•ã„。 è¨å®šä¾‹ã‚’見ã¦ã€å†—é•·ãªå‡ºåŠ›ãŒã‚ˆã‘ã‚Œã°è¨å®šã‚’変更ã—ã¦ãã ã•ã„。 デフォルトã§ã¯Hibernateã®ã‚¹ã‚¿ãƒ¼ãƒˆã‚¢ãƒƒãƒ—メッセージã ã‘ãŒæ¨™æº–出力ã«è¡¨ç¤ºã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr "ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã®ã‚¤ãƒ³ãƒ•ãƒ©ã¯å®Œå…¨ã§ã™ã€‚ Hibernateを使ã£ã¦å®Ÿéš›ã®ä½œæ¥ã‚’ã™ã‚‹æº–å‚™ãŒæ•´ã„ã¾ã—ãŸã€‚"
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr "オブジェクトã®ãƒãƒ¼ãƒ‰ã¨æ ¼ç´"
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr "ã¤ã„ã«ã‚ªãƒ–ジェクトã®ãƒãƒ¼ãƒ‰ã¨æ ¼ç´ã«Hibernateを使ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ <literal>main()</literal> メソッドをæŒã¤ <literal>EventManager</literal> クラスを書ãã¾ã™ï¼š"
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;
+\n"
+ "import org.hibernate.Session;
+\n"
+ "
+\n"
+ "import java.util.Date;
+\n"
+ "
+\n"
+ "import util.HibernateUtil;
+\n"
+ "
+\n"
+ "public class EventManager {
+\n"
+ "
+\n"
+ " public static void main(String[] args) {
+\n"
+ " EventManager mgr = new EventManager();
+\n"
+ "
+\n"
+ " if (args[0].equals(\"store\")) {
+\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());
+\n"
+ " }
+\n"
+ "
+\n"
+ " HibernateUtil.getSessionFactory().close();
+\n"
+ " }
+\n"
+ "
+\n"
+ " private void createAndStoreEvent(String title, Date theDate) {
+\n"
+ "
+\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ "
+\n"
+ " session.beginTransaction();
+\n"
+ "
+\n"
+ " Event theEvent = new Event();
+\n"
+ " theEvent.setTitle(title);
+\n"
+ " theEvent.setDate(theDate);
+\n"
+ "
+\n"
+ " session.save(theEvent);
+\n"
+ "
+\n"
+ " session.getTransaction().commit();
+\n"
+ " }
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr "æ–°ã—ã„ <literal>Event</literal> オブジェクトを生æˆã—ã€ãれをHibernateã«æ¸¡ã—ã¾ã™ã€‚ 今ã§ã¯HibernateãŒSQLを処ç†ã—ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã§ <literal>INSERT</literal> を実行ã—ã¾ã™ã€‚ 実行å‰ã« <literal>Session</literal> 㨠<literal>Transaction</literal> を処ç†ã™ã‚‹ã‚³ãƒ¼ãƒ‰ã‚’確èªã—ã¦ãã ã•ã„。"
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr "<literal>Session</literal> ã¯1ã¤ã®ä½œæ¥å˜ä½(Unit of Work)ã§ã™ã€‚ 当分ã®é–“ã€è©±ã‚’ç°¡å˜ã«ã™ã‚‹ãŸã‚ã«ã€ <literal>Session</literal> 㨠<literal>Transaction</literal> ã®å¯¾å¿œã‚’一対一ã¨ä»®å®šã—ã¾ã™ã€‚ 使用ã—ã¦ã„るトランザクション・システム（ã“ã®ã‚±ãƒ¼ã‚¹ã§ã¯JTAã¨å…±å˜ã§ãã‚‹å˜ç´”ãªJDBC）ã‹ã‚‰ã‚³ãƒ¼ãƒ‰ã‚’ä¿è·ã™ã‚‹ãŸã‚ã«ã€ Hibernate <literal>Session</literal> 上ã§åˆ©ç”¨å¯èƒ½ãª <literal>Transaction</literal> APIを使用ã—ã¾ã™ã€‚"
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr "<literal>sessionFactory.getCurrentSession()</literal> ã¯ãªã«ã‚’ã™ã‚‹ã®ã§ã—ょã†ã‹ï¼Ÿ ã¾ãšã€ã„ã£ãŸã‚“ <literal>SessionFactory</literal> ã‚’å–å¾—ã—ä¿æŒã™ã‚Œã° （ <literal>HibernateUtil</literal> ã®ãŠã‹ã’ã§ç°¡å˜ã§ã™ï¼‰ã€ã“ã®ãƒ¡ã‚½ãƒƒãƒ‰ã‚’何度ã§ã‚‚〠ã©ã“ã‹ã‚‰ã§ã‚‚呼ã³å‡ºã™ã“ã¨ãŒå‡ºæ¥ã¾ã™ã€‚ <literal>getCurrentSession()</literal> メソッドã¯å¸¸ã«ã€Œç¾åœ¨ã®ã€ä½œæ¥å˜ä½(Unit of Work)ã‚’è¿”ã—ã¾ã™ã€‚ <literal>hibernate.cfg.xml</literal> ã®ã“ã®æ©Ÿèƒ½ã®è¨å®šã§ã€\"thread\"を指定ã—ãŸã“ã¨ã‚’æ€ã„出ã—ã¦ãã ã•ã„。 ã“ã®ãŸã‚ç¾åœ¨ã®ä½œæ¥å˜ä½ã®ã‚¹ã‚³ãƒ¼ãƒ—ã¯ã€ã“ã®ã‚¢ãƒ—リケーションを実行ã™ã‚‹ç¾åœ¨ã®Javaスレッドã§ã™ã€‚ ã—ã‹ã—ã“ã‚Œã§å…¨ã¦ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 <literal>Session</literal> ã¯æœ€åˆã«å¿…è¦ã¨ãªã£ãŸã¨ãã€ã¤ã¾ã‚Šæœ€åˆã« <literal>getCurrentSession()</literal> ㌠呼ã°ã‚ŒãŸã¨ãã«é–‹å§‹ã—ã¾ã™ã€‚ ãã®ã¨ãHibernateã«ã‚ˆã‚Šç¾åœ¨ã!
®ã‚¹ãƒ¬ãƒƒãƒ‰ã«çµã³ä»˜ã‘られã¾ã™ã€‚ トランザクションãŒçµ‚了（コミットもã—ãã¯ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ï¼‰ã—ãŸã¨ã〠Hibernateもスレッドã‹ã‚‰ <literal>Session</literal> を切り離ã—ã€ã‚¯ãƒãƒ¼ã‚ºã—ã¾ã™ã€‚ å†ã³ <literal>getCurrentSession()</literal> を呼ã¶ã¨ã€ æ–°ã—ã„ <literal>Session</literal> ã‚’å–å¾—ã—ã¦æ–°ã—ã„作æ¥å˜ä½ã‚’スタートã§ãã¾ã™ã€‚ ã“ã® <emphasis>thread-bound</emphasis> プãƒã‚°ãƒ©ãƒŸãƒ³ã‚°ãƒ»ãƒ¢ãƒ‡ãƒ«ã¯Hibernateを利用ã™ã‚‹ä¸Šã§æœ€ã‚‚人気ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr "トランザクションã®æ‰±ã„ã¨å¢ƒç•Œã®è©³ã—ã„æƒ…å ±ã«ã¤ã„ã¦ã¯ã€ <xref linkend=\"transactions\"/> を見ã¦ãã ã•ã„。 ã“ã®ä¾‹ã§ã¯ã‚¨ãƒ©ãƒ¼å‡¦ç†ã‚„ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã‚‚割愛ã—ã¾ã™ã€‚"
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr "ã“ã®æœ€åˆã®ãƒ«ãƒ¼ãƒãƒ³ã‚’実行ã™ã‚‹ã«ã¯ã€Antã®ãƒ“ルドファイルã«å‘¼ã³å‡ºã—å¯èƒ½ãªã‚¿ãƒ¼ã‚²ãƒƒãƒˆã‚’ è¿½åŠ ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“："
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">
+\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">
+\n"
+ " <classpath path=\"${targetdir}\"/>
+\n"
+ " <arg value=\"${action}\"/>
+\n"
+ " </java>
+\n"
+ "</target>]]>"
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr "<literal>action</literal> 引数ã®å€¤ã¯ã€ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã‚’呼ã¶ã¨ãã«ã‚³ãƒžãƒ³ãƒ‰ãƒ©ã‚¤ãƒ³ã§è¨å®šã—ã¾ã™ï¼š"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr "<![CDATA[C:¥hibernateTutorial¥>ant run -Daction=store]]>"
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr "コンパイルã™ã‚‹ã¨ã€HibernateãŒã‚¹ã‚¿ãƒ¼ãƒˆã—ã€ã‚ãªãŸã®è¨å®šã«ã‚ˆã‚Šã¾ã™ãŒã€ 多ãã®ãƒã‚°å‡ºåŠ›ãŒã‚ã‚‹ã¯ãšã§ã™ã€‚ ãã®æœ€å¾Œã«ã¯ä»¥ä¸‹ã®è¡ŒãŒã‚ã‚‹ã§ã—ょã†ï¼š"
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr "ã“ã‚Œã¯HibernateãŒå®Ÿè¡Œã™ã‚‹ <literal>INSERT</literal> ã§ã€ クエスãƒãƒ§ãƒ³ãƒžãƒ¼ã‚¯ã¯JDBCãƒã‚¤ãƒ³ãƒ‰ãƒ‘ラメータを表ã—ã¦ã„ã¾ã™ã€‚ 引数ã¨ã—ã¦ãƒã‚¤ãƒ³ãƒ‰ã•ã‚Œã‚‹å€¤ã‚’見るãŸã‚ã€ã‚ã‚‹ã„ã¯ãƒã‚°ã®å†—長性を減らã™ãŸã‚ã«ã¯ã€ <literal>log4j.properties</literal> ã‚’ãƒã‚§ãƒƒã‚¯ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr "ãã‚Œã§ã¯åŒã˜ã‚ˆã†ã«æ ¼ç´ã•ã‚ŒãŸã‚¤ãƒ™ãƒ³ãƒˆã®ä¸€è¦§ã‚’見よã†ã¨æ€ã„ã¾ã™ã€‚ ãã®ãŸã‚メインメソッドã«ã‚ªãƒ—ã‚·ãƒ§ãƒ³ã‚’è¿½åŠ ã—ã¾ã™ï¼š"
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr ""
+ "<![CDATA[if (args[0].equals(\"store\")) {
+\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());
+\n"
+ "}
+\n"
+ "else if (args[0].equals(\"list\")) {
+\n"
+ " List events = mgr.listEvents();
+\n"
+ " for (int i = 0; i < events.size(); i++) {
+\n"
+ " Event theEvent = (Event) events.get(i);
+\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +
+\n"
+ " \" Time: \" + theEvent.getDate());
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr "æ–°ã—ã„ <literal>listEvents()メソッド</literal> ã‚‚è¿½åŠ ã—ã¾ã™ã€‚"
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private List listEvents() {
+\n"
+ "
+\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ "
+\n"
+ " session.beginTransaction();
+\n"
+ "
+\n"
+ " List result = session.createQuery(\"from Event\").list();
+\n"
+ "
+\n"
+ " session.getTransaction().commit();
+\n"
+ "
+\n"
+ " return result;
+\n"
+ "}]]>"
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr "ã“ã“ã§ã™ã‚‹ã“ã¨ã¯ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‹ã‚‰å˜åœ¨ã™ã‚‹ã™ã¹ã¦ã® <literal>Event</literal> オブジェクトをãƒãƒ¼ãƒ‰ã™ã‚‹HQL (Hibernate Query Language) クエリを使ã†ã“ã¨ã§ã™ã€‚ Hibernateã¯é©åˆ‡ãªSQLを生æˆã—ã€ãれをデータベースã«é€ã‚Šã€ ãã®ãƒ‡ãƒ¼ã‚¿ã‚’使ã£ã¦ <literal>Event</literal> オブジェクトを生æˆã—ã¾ã™ã€‚ 当然HQLã§ã•ã‚‰ã«è¤‡é›‘ãªã‚¯ã‚¨ãƒªã‚’作æˆã§ãã¾ã™ã€‚"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr "以下ã®ã‚¹ãƒ†ãƒƒãƒ—ã§ã€ã™ã¹ã¦ã®å®Ÿè¡Œã¨ãƒ†ã‚¹ãƒˆã‚’è¡Œã„ã¾ã™ã€‚"
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr "hbm2ddlを通ã™å‰ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã®ãƒ‡ãƒ¼ã‚¿ã‚’作æˆã—ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマを生æˆã™ã‚‹ãŸã‚ã«ã€ <literal>ant run -Daction=store</literal> を実行ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr "今㯠<literal>hibernate.cfg.xml</literal> ファイルã®ãƒ—ãƒãƒ‘ティをコメントアウトã—ã¦hbm2ddlを無効ã«ã—ã¦ãã ã•ã„。 通常ã¯ç¶™ç¶šçš„ã«å˜ä½“テストをã—ã¦ã„ã‚‹é–“ã¯hbm2ddlを有効ã«ã—ã¦ãŠãã®ã§ã™ãŒã€ ãれ以外ã®å ´åˆã«hbm2ddlã‚’èµ·å‹•ã™ã‚‹ã¨æ ¼ç´ã—ã¦ãŠã„ãŸå…¨ã¦ã®ãƒ‡ãƒ¼ã‚¿ã‚’ <emphasis>ドãƒãƒƒãƒ—</emphasis> ã™ã‚‹ã§ã—ょã†ã€‚ è¨å®šã‚’ <literal>create</literal> ã«ã™ã‚‹ã¨ã€çµæžœã¨ã—㦠「SessionFactory生æˆã®éš›ã€ã‚¹ã‚ーマã‹ã‚‰å…¨ã¦ã®ãƒ†ãƒ¼ãƒ–ルをドãƒãƒƒãƒ—ã—ã¦å†ä½œæˆã™ã‚‹ã€ã¨ã„ã†è¨å®šã«ãªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr "今 <literal>-Daction=list</literal> ã¨æŒ‡å®šã—ã¦Antを呼ã¶ã¨ã€ ã“ã‚Œã¾ã§æ ¼ç´ã—ãŸã‚¤ãƒ™ãƒ³ãƒˆãŒè¦‹ãˆã‚‹ã¯ãšã§ã™ã€‚ <literal>store</literal> アクションを数回以上呼ã¶ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚"
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr "注æ„：åˆã‚ã¦Hibernateã«è§¦ã‚Œã‚‹äººã€…ã®å¤šããŒã“ã“ã§å¤±æ•—ã™ã‚‹ãŸã‚ã€<emphasis>Table not found</emphasis> エラーメッセージ㫠関ã™ã‚‹è³ªå•ã‚’定期的ã«è¦‹ã‹ã‘ã¾ã™ã€‚ ã—ã‹ã—上記ã®ã‚¹ãƒ†ãƒƒãƒ—ã«å¾“ãˆã°ã€hbm2ddlãŒæœ€åˆã«å®Ÿè¡Œã•ã‚ŒãŸã¨ãã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマを作æˆã—〠ãã®å¾Œã®å®Ÿè¡Œã«ãŠã„ã¦ã‚‚ã“ã®ã‚¹ã‚ーマを使用ã™ã‚‹ã®ã§ã€å•é¡Œã¯èµ·ã“らãªã„ã§ã—ょã†ã€‚ マッピングやデータベーススã‚ーマを変更ã—ãŸã¨ãã¯ã€ã‚‚ã†ä¸€åº¦hbm2ddlを有効ã«ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr "パート2 - 関連ã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr "永続エンティティクラスをテーブルã«ãƒžãƒƒãƒ”ングã—ã¾ã—ãŸã€‚ ã•ã‚‰ã«ã“ã®ä¸Šã«ã„ãã¤ã‹ã®ã‚¯ãƒ©ã‚¹ã®é–¢é€£ã‚’è¿½åŠ ã—ã¾ã—ょã†ã€‚ ã¾ãšåˆã‚ã«ã‚¢ãƒ—リケーションã«äººã€…ã‚’è¿½åŠ ã—ã€å½¼ã‚‰ãŒå‚åŠ ã™ã‚‹ã‚¤ãƒ™ãƒ³ãƒˆã®ãƒªã‚¹ãƒˆã‚’æ ¼ç´ã—ã¾ã™ã€‚"
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr "Personクラスã®ãƒžãƒƒãƒ”ング"
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr "最åˆã® <literal>Person</literal> クラスã¯å˜ç´”ã§ã™ï¼š"
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr ""
+ "<![CDATA[package events;
+\n"
+ "
+\n"
+ "public class Person {
+\n"
+ "
+\n"
+ " private Long id;
+\n"
+ " private int age;
+\n"
+ " private String firstname;
+\n"
+ " private String lastname;
+\n"
+ "
+\n"
+ " public Person() {}
+\n"
+ "
+\n"
+ " // Accessor methods for all properties, private setter for 'id'
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr "<literal>Person.hbm.xml</literal> ã¨ã„ã†æ–°ã—ã„マッピングファイルを作æˆã—ã¦ãã ã•ã„ （ファイルã®æœ€åˆã«DTDã¸ã®å‚照を忘れãšã«å…¥ã‚Œã¦ãã ã•ã„）："
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>
+\n"
+ "
+\n"
+ " <class name=\"events.Person\" table=\"PERSON\">
+\n"
+ " <id name=\"id\" column=\"PERSON_ID\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"age\"/>
+\n"
+ " <property name=\"firstname\"/>
+\n"
+ " <property name=\"lastname\"/>
+\n"
+ " </class>
+\n"
+ "
+\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr "最後ã«Hibernateã®è¨å®šã«æ–°ã—ã„ãƒžãƒƒãƒ”ãƒ³ã‚°ã‚’è¿½åŠ ã—ã¦ãã ã•ã„："
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>
+\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr "ãã‚Œã§ã¯ã“れら2ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£é–“ã®é–¢é€£ã‚’作æˆã—ã¾ã™ã€‚ 人々ãŒã‚¤ãƒ™ãƒ³ãƒˆã«å‚åŠ ã§ãã€ã‚¤ãƒ™ãƒ³ãƒˆãŒå‚åŠ è€…ã‚’æŒã¤ã®ã¯æ˜Žã‚‰ã‹ã§ã™ã€‚ 扱ã‚ãªã‘ã‚Œã°ãªã‚‰ãªã„è¨è¨ˆã®å•é¡Œã¯ã€æ–¹å‘ã€å¤šé‡åº¦ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®æŒ¯ã‚‹èˆžã„ã§ã™ã€‚"
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr "å˜æ–¹å‘Setベース関連"
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr "イベントã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ <literal>Person</literal> クラスã«è¿½åŠ ã—ã¾ã™ã€‚ ã“ã†ã—ã¦ãŠãã¨ã€æ˜Žç¤ºçš„ãªã‚¯ã‚¨ãƒªã€ã¤ã¾ã‚Šã‚ã–ã‚ã–<literal>aPerson.getEvents()</literal>を呼ã³å‡ºã•ãšã«ã€ 特定ã®äººã«ç´ä»˜ãイベントを簡å˜ã«ãƒŠãƒ“ゲートã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ç§ãŸã¡ã¯Javaã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã€<literal>Set</literal> を使ã„ã¾ã™ã€‚ コレクションã¯é‡è¤‡è¦ç´ ã‚’æŒãŸãªã„ã—ã€é †ç•ªã¯ç§ãŸã¡ã«ã¯æ„味ãŒãªã„ã‹ã‚‰ã§ã™ã€‚"
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr "<literal>Set</literal> ã§å®Ÿè£…ã•ã‚Œã‚‹å˜æ–¹å‘ã€å¤šå€¤é–¢é€£ãŒå¿…è¦ã§ã™ã€‚ Javaクラス内ã«å¯¾å¿œã™ã‚‹ã‚³ãƒ¼ãƒ‰ã‚’書ã„ã¦ãƒžãƒƒãƒ”ングã—ã¾ã—ょã†ï¼š"
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr ""
+ "<![CDATA[public class Person {
+\n"
+ "
+\n"
+ " private Set events = new HashSet();
+\n"
+ "
+\n"
+ " public Set getEvents() {
+\n"
+ " return events;
+\n"
+ " }
+\n"
+ "
+\n"
+ " public void setEvents(Set events) {
+\n"
+ " this.events = events;
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr "ã“ã®é–¢é€£ã‚’マッピングã™ã‚‹å‰ã«ã€å対å´ã«ã¤ã„ã¦è€ƒãˆã¦ãã ã•ã„。 明らã‹ãªã“ã¨ã§ã™ãŒã€ä»Šã¯ã“れをå˜æ–¹å‘ã«ã—ãŸã ã‘ã§ã™ã€‚ 逆ã«ã€ <literal>Event</literal> å´ã«ã‚‚別ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’作るã“ã¨ã‚‚ã§ãã¾ã™ã€‚ 例ãˆã° <literal>anEvent.getParticipants()</literal> ã®ã‚ˆã†ã«ã€ åŒæ–¹å‘ã«ãƒŠãƒ“ゲートã—ãŸã‘ã‚Œã°ã€ãã†ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ã“ã‚Œã¯æ©Ÿèƒ½çš„ã«ã¿ã¦å¿…è¦ã§ã¯ã‚ã‚Šã¾ã›ã‚“。 特定ã®ã‚¤ãƒ™ãƒ³ãƒˆã«é–¢ä¿‚ã™ã‚‹ãƒ‡ãƒ¼ã‚¿ã‚’å–å¾—ã™ã‚‹æ˜Žç¢ºãªã‚¯ã‚¨ãƒªã‚’ã€ã„ã¤ã§ã‚‚実行ã™ã‚‹ã“ã¨ãŒå‡ºæ¥ã¾ã—ãŸã€‚ ã“ã®è¨è¨ˆã®é¸æŠžã¯é–‹ç™ºè€…ã«ä»»ã•ã‚Œã¦ã„ã¦ã€ã“ã®è°è«–ã«ã‚ˆã‚Šæ˜Žã‚‰ã‹ãªã®ã¯é–¢é€£ã®å¤šé‡åº¦ã§ã™ã€‚ ã¤ã¾ã‚Šä¸¡å´ã‚’「多ã€å€¤ã«ã™ã‚‹ã€ <emphasis>多対多</emphasis> ã¨å‘¼ã°ã‚Œã‚‹é–¢é€£ã§ã™ã€‚ ãã®ãŸã‚Hibernateã®many-to-manyマッピングを使ã„ã¾ã™ï¼š"
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">
+\n"
+ " <id name=\"id\" column=\"PERSON_ID\">
+\n"
+ " <generator class=\"native\"/>
+\n"
+ " </id>
+\n"
+ " <property name=\"age\"/>
+\n"
+ " <property name=\"firstname\"/>
+\n"
+ " <property name=\"lastname\"/>
+\n"
+ "
+\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">
+\n"
+ " <key column=\"PERSON_ID\"/>
+\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>
+\n"
+ " </set>
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr "Hibernateã¯ã‚ã‚Šã¨ã‚らゆる種類ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒžãƒƒãƒ”ングをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ãŒã€ 最も一般的ãªã‚‚ã®ãŒ <literal><set></literal> ã§ã™ã€‚ 多対多関連（ã¾ãŸã¯ <emphasis>n:m</emphasis> エンティティリレーションシップ）ã«ã¯ã€ 関連テーブルãŒå¿…è¦ã§ã™ã€‚ ã“ã®ãƒ†ãƒ¼ãƒ–ルã®ãã‚Œãžã‚Œã®è¡Œã¯ã€äººã¨ã‚¤ãƒ™ãƒ³ãƒˆé–“ã®ãƒªãƒ³ã‚¯ã‚’表ç¾ã—ã¾ã™ã€‚ テーブルå㯠<literal>set</literal> è¦ç´ ã® <literal>table</literal> 属性ã§è¨å®šã—ã¾ã™ã€‚ 人å´ã®é–¢é€£ã®è˜åˆ¥åカラムå㯠<literal><key></literal> è¦ç´ ã§ã€ イベントå´ã®ã‚«ãƒ©ãƒ å㯠<literal><many-to-many></literal> ã® <literal>column</literal> 属性ã§å®šç¾©ã—ã¾ã™ã€‚ Hibernateã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚ªãƒ–ジェクトã®ã‚¯ãƒ©ã‚¹ （æ£ç¢ºã«ã¯ã€å‚ç…§ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®å対å´ã®ã‚¯ãƒ©ã‚¹ï¼‰ã‚’æ•™ãˆãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr "ãã®ãŸã‚ã“ã®ãƒžãƒƒãƒ”ングã®ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚："
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr ""
+ "<![CDATA[
+\n"
+ " _____________ __________________
+\n"
+ " | | | | _____________
+\n"
+ " | EVENTS | | PERSON_EVENT | | |
+\n"
+ " |_____________| |__________________| | PERSON |
+\n"
+ " | | | | |_____________|
+\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |
+\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |
+\n"
+ " | TITLE | |__________________| | AGE |
+\n"
+ " |_____________| | FIRSTNAME |
+\n"
+ " | LASTNAME |
+\n"
+ " |_____________|
+\n"
+ " ]]>"
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr "関連をåƒã‹ã›ã‚‹"
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr "<literal>EventManager</literal> ã®æ–°ã—ã„メソッドã§äººã€…ã¨ã‚¤ãƒ™ãƒ³ãƒˆã‚’一緒ã«ã—ã¾ã—ょã†ï¼š"
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {
+\n"
+ "
+\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ " session.beginTransaction();
+\n"
+ "
+\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);
+\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);
+\n"
+ "
+\n"
+ " aPerson.getEvents().add(anEvent);
+\n"
+ "
+\n"
+ " session.getTransaction().commit();
+\n"
+ "}]]>"
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr "<literal>Person</literal> 㨠<literal>Event</literal> ã‚’ãƒãƒ¼ãƒ‰ã—ãŸå¾Œã€ 普通ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒ¡ã‚½ãƒƒãƒ‰ã‚’使ã£ã¦å˜ç´”ã«ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ä¿®æ£ã—ã¦ãã ã•ã„。 ã”覧ã®ã¨ãŠã‚Š <literal>update()</literal> ã‚„ <literal>save()</literal> ã®æ˜Žç¤ºçš„ãªå‘¼ã³å‡ºã—ã¯ã‚ã‚Šã¾ã›ã‚“。 Hibernateã¯ã€ä¿®æ£ã•ã‚ŒãŸã“ã¨ã«ã‚ˆã‚Šæ›´æ–°ã™ã‚‹å¿…è¦ã®ã‚るコレクションを自動的ã«æ¤œçŸ¥ã—ã¾ã™ã€‚ ã“れ㯠<emphasis>自動ダーティãƒã‚§ãƒƒã‚¯</emphasis> ã¨å‘¼ã°ã‚Œã€ オブジェクトã®åå‰ã‚„dateプãƒãƒ‘ティを修æ£ã™ã‚‹ã“ã¨ã§è©¦ã™ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚ ãれら㌠<emphasis>永続</emphasis> 状態ã«ã‚ã‚‹é™ã‚Šã€ ã¤ã¾ã‚Šç‰¹å®šã®Hibernate <literal>Session</literal> ã«ãƒã‚¤ãƒ³ãƒ‰ã•ã‚Œã¦ã„ã‚‹é™ã‚Š （例ãˆã°ä½œæ¥å˜ä½(Unit of Work)ã®ä¸ã§å˜ã«ãƒãƒ¼ãƒ‰ã¾ãŸã¯ã‚»ãƒ¼ãƒ–ã•ã‚ŒãŸï¼‰ã€ Hibernateã¯ã©ã‚“ãªå¤‰æ›´ã‚‚モニターã—ã€é…延書ãè¾¼ã¿(write-behind)ã§SQLを実行ã—ã!
¾ã™ã€‚ 通常ã€ä½œæ¥å˜ä½(Unit of Work)ã®æœ€å¾Œã«ã ã‘è¡Œã‚れるデータベースã¨ãƒ¡ãƒ¢ãƒªã®çŠ¶æ…‹ã‚’åŒæœŸã•ã›ã‚‹å‡¦ç†ã¯ã€ <emphasis>フラッシュ</emphasis> ã¨å‘¼ã°ã‚Œã¾ã™ã€‚ ã“ã®ã‚³ãƒ¼ãƒ‰ã§ã¯ã€ä½œæ¥å˜ä½(Unit of Work)ã¯ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã®ã‚³ãƒŸãƒƒãƒˆï¼ˆã‚‚ã—ãã¯ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ï¼‰ã§çµ‚了ã—ã¾ã™ã€‚ ã“ã‚Œã¯ã€ <literal>CurrentSessionContext</literal> クラスã«å¯¾ã—㦠<literal>thread</literal> ã‚’è¨å®šã—ãŸãŸã‚ã§ã™ã€‚"
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr "ç•°ãªã‚‹ä½œæ¥å˜ä½(Unit of Work)ã§äººã€…ã¨ã‚¤ãƒ™ãƒ³ãƒˆã‚’ãƒãƒ¼ãƒ‰ã™ã‚‹ã“ã¨ã‚‚当然ã§ãã¾ã™ã€‚ ãã†ã§ãªã‘ã‚Œã°ã€æ°¸ç¶šçŠ¶æ…‹ã«ãªã„ã¨ã（以å‰ã«æ°¸ç¶šã§ã‚ã£ãŸãªã‚‰ã€ã“ã®çŠ¶æ…‹ã‚’ <emphasis>分離（detached）</emphasis> ã¨å‘¼ã³ã¾ã™ï¼‰ã€ <literal>Session</literal> ã®å¤–部ã§ã‚ªãƒ–ジェクトを修æ£ã—ã¾ã™ã€‚ 分離ã•ã‚Œã‚‹ã¨ãã«ã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’変更ã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ï¼š"
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {
+\n"
+ "
+\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ " session.beginTransaction();
+\n"
+ "
+\n"
+ " Person aPerson = (Person) session
+\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")
+\n"
+ " .setParameter(\"pid\", personId)
+\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached
+\n"
+ "
+\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);
+\n"
+ "
+\n"
+ " session.getTransaction().commit();
+\n"
+ "
+\n"
+ " // End of first unit of work
+\n"
+ "
+\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached
+\n"
+ "
+\n"
+ " // Begin second unit of work
+\n"
+ "
+\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ " session2.beginTransaction();
+\n"
+ "
+\n"
+ " session2.update(aPerson); // Reattachment of aPerson
+\n"
+ "
+\n"
+ " session2.getTransaction().commit();
+\n"
+ "}]]>"
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr "<literal>update</literal> ã®å‘¼ã³å‡ºã—ã¯åˆ†é›¢ã‚ªãƒ–ジェクトをå†ã³æ°¸ç¶šåŒ–ã—ã¾ã™ã€‚ ã“ã‚Œã¯ã€æ–°ã—ã„作æ¥å˜ä½(Unit of Work)ã«ãƒã‚¤ãƒ³ãƒ‰ã™ã‚‹ã¨è¨€ãˆã‚‹ã§ã—ょã†ã€‚ ãã®ãŸã‚分離ã®é–“ã«åŠ ãˆã‚‰ã‚ŒãŸã©ã®ã‚ˆã†ãªä¿®æ£ã‚‚データベースã«ã‚»ãƒ¼ãƒ–ã§ãã¾ã™ã€‚ エンティティオブジェクトã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¸ã®ä¿®æ£ï¼ˆè¿½åŠ ･削除）もåŒæ§˜ã«ã‚»ãƒ¼ãƒ–ã§ãã¾ã™ã€‚"
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr "ã“ã‚Œã¯ä»Šã¯ã‚ã¾ã‚Šä½¿ã„ã¿ã¡ãŒã‚ã‚Šã¾ã›ã‚“ãŒã€ 自分ã®ã‚¢ãƒ—リケーションã®è¨è¨ˆã«çµ„ã¿è¾¼ã‚€ã“ã¨ãŒã§ãã‚‹é‡è¦ãªã‚³ãƒ³ã‚»ãƒ—トã§ã™ã€‚ ãã‚Œã§ã¯ã“ã®ã‚¨ã‚¯ã‚µã‚µã‚¤ã‚ºã®æœ€å¾Œã«ã€ <literal>EventManager</literal> ã®ãƒ¡ã‚¤ãƒ³ãƒ¡ã‚½ãƒƒãƒ‰ã«æ–°ã—ã„ã‚¢ã‚¯ã‚·ãƒ§ãƒ³ã‚’è¿½åŠ ã—㦠コマンドラインã‹ã‚‰å‘¼ã³å‡ºã—ã¦ã¿ã¾ã—ょã†ã€‚ 人やイベントã®è˜åˆ¥åãŒå¿…è¦ãªã‚‰ã€ <literal>save()</literal> メソッドãŒè¿”ã—ã¦ãã‚Œã¾ã™ ï¼ˆå ´åˆã«ã‚ˆã£ã¦ã¯è˜åˆ¥åã‚’è¿”ã™ãŸã‚ã«ãƒ¡ã‚½ãƒƒãƒ‰ã‚’ä¿®æ£ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“）。"
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {
+\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());
+\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");
+\n"
+ " mgr.addPersonToEvent(personId, eventId);
+\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);
+\n"
+ "}]]>"
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr "ã“ã‚Œã¯åŒã˜ã‚ˆã†ã«é‡è¦ãª2ã¤ã®ã‚¯ãƒ©ã‚¹ã€ã¤ã¾ã‚Š2ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£é–“ã®é–¢é€£ã®ä¾‹ã§ã—ãŸã€‚ å‰ã«è¿°ã¹ãŸã‚ˆã†ã«ã€å…¸åž‹çš„ãªãƒ¢ãƒ‡ãƒ«ã«ã¯ã€æ™®é€šã€Œæ¯”較的é‡è¦ã§ã¯ãªã„ã€ä»–ã®ã‚¯ãƒ©ã‚¹ã¨åž‹ãŒã‚ã‚Šã¾ã™ã€‚ ã“ã‚Œã¾ã§ã«è¦‹ãŸã‚ˆã†ãª <literal>int</literal> ã‚„ <literal>String</literal> ã®ã‚ˆã†ãªã‚‚ã®ã§ã™ã€‚ ã“ã®ã‚ˆã†ãªã‚¯ãƒ©ã‚¹ã‚’ <emphasis>値型</emphasis> ã¨è¨€ã„ã¾ã™ã€‚ ã“ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ç‰¹å®šã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã« <emphasis>ä¾å˜</emphasis> ã—ã¾ã™ã€‚ ã“ã®åž‹ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã¯ç‹¬è‡ªã®IDã‚’æŒã¡ã¾ã›ã‚“ã—〠エンティティ間ã§å…±æœ‰ã•ã‚Œã‚‹ã“ã¨ã‚‚ã‚ã‚Šã¾ã›ã‚“ （ファーストãƒãƒ¼ãƒ ãŒåŒã˜ã ã£ãŸã¨ã—ã¦ã‚‚ã€2人ã®äººã¯åŒã˜ <literal>firstname</literal> オブジェクトをå‚ç…§ã—ã¾ã›ã‚“）。 値型ã¯ã‚‚ã¡ã‚ã‚“JDK内ã«è¦‹ã¤ã‹ã‚Šã¾ã™ãŒã€ãã‚Œã ã‘ã§ã¯ãªã （実際ã€Hibernateアプリケーションã«ãŠã„ã¦ã™ã¹ã¦ã®JDKã‚!
¯ãƒ©ã‚¹ã¯å€¤åž‹ã¨è¦‹ãªã›ã¾ã™ï¼‰ã€ 例ãˆã° <literal>Address</literal> ã‚„ <literal>MonetaryAmount</literal> ã®ã‚ˆã†ãªç‹¬è‡ªã®ä¾å˜ã‚¯ãƒ©ã‚¹ã‚’書ãã“ã¨ã‚‚ã§ãã¾ã™ã€‚"
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr "値型ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’è¨è¨ˆã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚ ã“ã‚Œã¯ä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚ç…§ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¨ã¯æ¦‚念的ã«éžå¸¸ã«ç•°ãªã‚Šã¾ã™ãŒã€ Javaã§ã¯ã»ã¨ã‚“ã©åŒã˜ã‚ˆã†ã«è¦‹ãˆã¾ã™ã€‚"
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr "値ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³"
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr "値型オブジェクトã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’ <literal>Person</literal> エンティティã¸è¿½åŠ ã—ã¾ã™ã€‚ Eãƒ¡ãƒ¼ãƒ«ã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’æ ¼ç´ã—ãŸã„ã®ã§ã™ãŒã€<literal>String</literal> 型を使ã£ã¦ã„ã‚‹ã®ã§ã€ コレクションã¯å†ã³ <literal>Set</literal> ã§ã™ï¼š"
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr ""
+ "<![CDATA[private Set emailAddresses = new HashSet();
+\n"
+ "
+\n"
+ "public Set getEmailAddresses() {
+\n"
+ " return emailAddresses;
+\n"
+ "}
+\n"
+ "
+\n"
+ "public void setEmailAddresses(Set emailAddresses) {
+\n"
+ " this.emailAddresses = emailAddresses;
+\n"
+ "}]]>"
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr "ã“ã® <literal>Set</literal> ã®ãƒžãƒƒãƒ”ングã§ã™ï¼š"
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">
+\n"
+ " <key column=\"PERSON_ID\"/>
+\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr "å‰ã®ãƒžãƒƒãƒ”ングã¨æ¯”ã¹ã¦é•ã†ã®ã¯ <literal>element</literal> ã®éƒ¨åˆ†ã§ã™ãŒã€ Hibernateã«ã“ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãŒä»–ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã¸ã®å‚照をå«ã¾ãšã€ <literal>String</literal> åž‹ã®è¦ç´ ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’å«ã‚€ã“ã¨ã‚’æ•™ãˆã¾ã™ã€‚ （å°æ–‡å—ã®åå‰(string)ã¯Hibernateã®ãƒžãƒƒãƒ”ング型ã¾ãŸã¯ã‚³ãƒ³ãƒãƒ¼ã‚¿ã§ã‚ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ï¼‰ã€‚ ç¹°ã‚Šè¿”ã—ã¾ã™ãŒã€<literal>set</literal> è¦ç´ ã® <literal>table</literal> 属性ã¯ã€ コレクションã®ãŸã‚ã®ãƒ†ãƒ¼ãƒ–ルåを指定ã—ã¾ã™ã€‚ <literal>key</literal> è¦ç´ ã¯ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒ†ãƒ¼ãƒ–ルã®å¤–部ã‚ーカラムåを定義ã—ã¾ã™ã€‚ <literal>element</literal> è¦ç´ ã® <literal>column</literal> 属性㯠<literal>String</literal> ã®å€¤ãŒå®Ÿéš›ã«æ ¼ç´ã•ã‚Œã‚‹ã‚«ãƒ©ãƒ ã®åå‰ã‚’定義ã—ã¾ã™ã€‚"
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr "æ›´æ–°ã—ãŸã‚¹ã‚ーマを見ã¦ãã ã•ã„："
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr ""
+ "<![CDATA[
+\n"
+ " _____________ __________________
+\n"
+ " | | | | _____________
+\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________
+\n"
+ " |_____________| |__________________| | PERSON | | |
+\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |
+\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|
+\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |
+\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |
+\n"
+ " |_____________| | FIRSTNAME | |___________________|
+\n"
+ " | LASTNAME |
+\n"
+ " |_____________|
+\n"
+ " ]]>"
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr "コレクションテーブルã®ä¸»ã‚ーã¯ã€å®Ÿéš›ã¯ä¸¡æ–¹ã®ã‚«ãƒ©ãƒ を使ã£ãŸè¤‡åˆã‚ーã§ã‚ã‚‹ã“ã¨ãŒã‚ã‹ã‚Šã¾ã™ã€‚ ã“ã‚Œã¯äººã”ã¨ã«EメールアドレスãŒé‡è¤‡ã§ããªã„ã¨ã„ã†ã“ã¨ã§ã€ Javaã®setã«è¦æ±‚ã•ã‚Œã‚‹ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ãã®ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr "以å‰äººã¨ã‚¤ãƒ™ãƒ³ãƒˆã‚’関連ã¥ã‘ãŸã¨ãã¨å…¨ãåŒã˜ã‚ˆã†ã«ã€ 今や試ã—ã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«è¦ç´ ã‚’è¿½åŠ ã™ã‚‹ã“ã¨ãŒã§ãるよã†ã«ãªã‚Šã¾ã—ãŸã€‚ 両方ã¨ã‚‚Javaã§ã¯åŒã˜ã‚³ãƒ¼ãƒ‰ã§ã™ã€‚"
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {
+\n"
+ "
+\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();
+\n"
+ " session.beginTransaction();
+\n"
+ "
+\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);
+\n"
+ "
+\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection
+\n"
+ " aPerson.getEmailAddresses().add(emailAddress);
+\n"
+ "
+\n"
+ " session.getTransaction().commit();
+\n"
+ "}]]>"
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr "今回ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã®åˆæœŸåŒ–ã« <emphasis>fetch</emphasis> クエリを使用ã—ã¾ã›ã‚“ã§ã—ãŸã€‚ ãã®ãŸã‚ã€getterメソッドã®å‘¼ã³å‡ºã—ã«ã‚ˆã£ã¦ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’åˆæœŸåŒ–ã™ã‚‹ãŸã‚ã®SELECT㌠実行ã•ã‚Œã‚‹ã®ã§ã€ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«è¦ç´ ã‚’è¿½åŠ ã§ãã¾ã™ã€‚ SQLã®ãƒã‚°ã‚’監視ã—ã¦ã€å³æ™‚フェッãƒã‚’使ã£ã¦æœ€é©åŒ–ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr "åŒæ–¹å‘関連"
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr "次ã«åŒæ–¹å‘関連をマッピングã—ã¾ã™ã€‚ Javaã§ä¸¡å´ã‹ã‚‰äººã¨ã‚¤ãƒ™ãƒ³ãƒˆã®é–¢é€£ã‚’動作ã•ã›ã¾ã™ã€‚ ã‚‚ã¡ã‚ã‚“ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã‚¹ã‚ーマã¯å¤‰ã‚ã‚Šã¾ã›ã‚“ãŒã€å¤šé‡åº¦ã¯å¤šå¯¾å¤šã®ã¾ã¾ã§ã™ã€‚ リレーショナルデータベースã¯ãƒãƒƒãƒˆãƒ¯ãƒ¼ã‚¯ãƒ—ãƒã‚°ãƒ©ãƒŸãƒ³ã‚°è¨€èªžã‚ˆã‚Šã‚‚柔軟ãªã®ã§ã€ ナビゲーションã®æ–¹å‘ã®ã‚ˆã†ãªã‚‚ã®ã‚’å¿…è¦ã¨ã—ã¾ã›ã‚“。 データã¯ã‚らゆるã®æ–¹æ³•ã§è¦‹ãŸã‚Šå¾©å…ƒã§ãã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚"
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr "ã¾ãš <literal>Event</literal> イベントクラスã«å‚åŠ è€…ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’è¿½åŠ ã—ã¾ã™ï¼š"
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr ""
+ "<![CDATA[private Set participants = new HashSet();
+\n"
+ "
+\n"
+ "public Set getParticipants() {
+\n"
+ " return participants;
+\n"
+ "}
+\n"
+ "
+\n"
+ "public void setParticipants(Set participants) {
+\n"
+ " this.participants = participants;
+\n"
+ "}]]>"
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr "ãã‚Œã§ã¯ <literal>Event.hbm.xml</literal> ã§é–¢é€£ã®ã“ã¡ã‚‰å´ã‚’マッピングã—ã¦ãã ã•ã„。"
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">
+\n"
+ " <key column=\"EVENT_ID\"/>
+\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>
+\n"
+ "</set>]]>"
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr "ã”覧ã®ã¨ãŠã‚Šã€ã„ãšã‚Œã®ãƒžãƒƒãƒ”ングドã‚ュメント(XMLファイル)ã§ã‚‚ã€æ™®é€šã® <literal>set</literal> マッピングを使ã£ã¦ã„ã¾ã™ã€‚ <literal>key</literal> 㨠<literal>many-to-many</literal> ã®ã‚«ãƒ©ãƒ åãŒã€ 両方ã®ãƒžãƒƒãƒ”ングドã‚ュメントã§å…¥ã‚Œæ›¿ãˆã«ãªã£ã¦ã„ã‚‹ã“ã¨ã«æ³¨ç›®ã—ã¦ãã ã•ã„。 ã“ã“ã§æœ€ã‚‚é‡è¦ãªè¿½åŠ é …ç›®ã¯ã€ <literal>Event</literal> ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ãƒžãƒƒãƒ”ング㮠<literal>set</literal> è¦ç´ ã«ã‚ã‚‹ <literal>inverse=\"true\"</literal> 属性ã§ã™ã€‚"
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr "ã“ã®æŒ‡å®šã®æ„味ã¯ã€2ã¤ã®é–“ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£é–“ã®ãƒªãƒ³ã‚¯ã«ã¤ã„ã¦ã®æƒ…å ±ã‚’æŽ¢ã™å¿…è¦ãŒã‚ã‚‹ã¨ã〠Hibernateã¯å対å´ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã€ã¤ã¾ã‚Š <literal>Person</literal> クラスã‹ã‚‰æŽ¢ã™ã¨ã„ã†ã“ã¨ã§ã™ã€‚ 一度2ã¤ã®ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£é–“ã®åŒæ–¹å‘リンクãŒã©ã®ã‚ˆã†ã«ä½œæˆã•ã‚Œã‚‹ã‹ãŒã‚ã‹ã‚Œã°ã€ ã“れをç†è§£ã™ã‚‹ã“ã¨ã¯ã¨ã¦ã‚‚ç°¡å˜ã§ã™ã€‚"
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr "åŒæ–¹å‘リンクã®å‹•ä½œ"
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr "ã¾ãšã€HibernateãŒé€šå¸¸ã®Javaã®ã‚»ãƒžãƒ³ãƒ†ã‚£ã‚¯ã‚¹ã«å½±éŸ¿ã‚’åŠã¼ã•ãªã„ã“ã¨ã‚’心ã«ç•™ã‚ã¦ãŠã„ã¦ãã ã•ã„。 ç§ãŸã¡ã¯ã€å˜æ–¹å‘ã®ä¾‹ã¨ã—ã¦ã©ã®ã‚ˆã†ã« <literal>Person</literal> 㨠<literal>Event</literal> ã®é–“ã®ãƒªãƒ³ã‚¯ã‚’作æˆã—ãŸã§ã—ょã†ã‹ï¼Ÿ <literal>Person</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã®ã‚¤ãƒ™ãƒ³ãƒˆã¸ã®å‚ç…§ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã« <literal>Event</literal> ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ã‚’è¿½åŠ ã—ã¾ã—ãŸã€‚ ãã®ãŸã‚ã“ã®ãƒªãƒ³ã‚¯ã‚’åŒæ–¹å‘ã«ã—ãŸã‘ã‚Œã°ã€ 当ãŸã‚Šå‰ã§ã™ãŒå対å´ã«ã‚‚åŒã˜ã“ã¨ã‚’ã—ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 <literal>Event</literal> ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã« <literal>Person</literal> ã¸ã® å‚ç…§ã‚’è¿½åŠ ã™ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ã“ã®ã€Œä¸¡å´ã§ãƒªãƒ³ã‚¯ã‚’è¨å®šã™ã‚‹ã“ã¨ã€ã¯çµ¶å¯¾ã«å¿…è¦ãªã®ã§ã€æ±ºã—ã¦å¿˜ã‚Œãªã„ã§ãã ã•ã„。"
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr "多ãã®é–‹ç™ºè€…ã¯æ…Žé‡ã«ãƒ—ãƒã‚°ãƒ©ãƒ ã™ã‚‹ã®ã§ã€ エンティティã®ä¸¡å´ã«æ£ã—ã関連をè¨å®šã™ã‚‹ãƒªãƒ³ã‚¯ç®¡ç†ãƒ¡ã‚½ãƒƒãƒ‰ã‚’作æˆã—ã¾ã™ã€‚ 例ãˆã° <literal>Person</literal> ã§ã¯ä»¥ä¸‹ã®ã‚ˆã†ã«ãªã‚Šã¾ã™ã€‚："
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr ""
+ "<![CDATA[protected Set getEvents() {
+\n"
+ " return events;
+\n"
+ "}
+\n"
+ "
+\n"
+ "protected void setEvents(Set events) {
+\n"
+ " this.events = events;
+\n"
+ "}
+\n"
+ "
+\n"
+ "public void addToEvent(Event event) {
+\n"
+ " this.getEvents().add(event);
+\n"
+ " event.getParticipants().add(this);
+\n"
+ "}
+\n"
+ "
+\n"
+ "public void removeFromEvent(Event event) {
+\n"
+ " this.getEvents().remove(event);
+\n"
+ " event.getParticipants().remove(this);
+\n"
+ "}]]>"
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr "コレクションã®ã‚²ãƒƒãƒˆã¨ã‚»ãƒƒãƒˆãƒ¡ã‚½ãƒƒãƒ‰ãŒç¾åœ¨protectedã«ãªã£ã¦ã„ã‚‹ã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã‚Œã¯åŒã˜ãƒ‘ッケージã®ã‚¯ãƒ©ã‚¹ã‚„サブクラスã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ä¾ç„¶ã‚¢ã‚¯ã‚»ã‚¹ãŒå¯èƒ½ã§ã™ãŒã€ （ã»ã¨ã‚“ã©ï¼‰ãã®ãƒ‘ッケージ外ã®ã©ã®ã‚¯ãƒ©ã‚¹ã§ã‚‚直接ãã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’å°ç„¡ã—ã«ã™ã‚‹ã“ã¨ã‚’防ãŽã¾ã™ã€‚ ãŠãらãå対å´ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã«ã‚‚åŒã˜ã“ã¨ã‚’ã—ãŸæ–¹ãŒã„ã„ã§ã—ょã†ã€‚"
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr "<literal>inverse</literal> マッピング属性ã¨ã¯ã„ã£ãŸã„何ã§ã—ょã†ã‹ï¼Ÿ 開発者ã¨Javaã«ã¨ã£ã¦ã¯ã€åŒæ–¹å‘リンクã¯å˜ã«ä¸¡å´ã®å‚照をæ£ã—ãè¨å®šã™ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ ã—ã‹ã—Hibernateã¯ï¼ˆåˆ¶ç´„é•åã‚’é¿ã‘ã‚‹ãŸã‚ã«ï¼‰SQLã® <literal>INSERT</literal> 㨠<literal>UPDATE</literal> 文をæ£ç¢ºã«å¤‰æ›´ã™ã‚‹ãŸã‚ã®å分ãªæƒ…å ±ã‚’æŒã£ã¦ã„ãªã„ã®ã§ã€ åŒæ–¹å‘関連プãƒãƒ‘ティを扱ã†ãŸã‚ã®ä½•ã‚‰ã‹ã®åŠ©ã‘ã‚’å¿…è¦ã¨ã—ã¾ã™ã€‚ 関連ã®ç‰‡å´ã‚’ <literal>inverse</literal> ã«è¨å®šã™ã‚‹ã“ã¨ã§ã€Hibernateã¯åŸºæœ¬çš„ã«ã¯è¨å®šã—ãŸå´ã‚’無視ã—〠å対å´ã® <emphasis>é¡</emphasis> ã¨ã—ã¦è€ƒãˆã¾ã™ã€‚ ã“ã‚Œã ã‘ã§ã€Hibernateã¯æ–¹å‘ã‚’æŒã¤ãƒŠãƒ“ゲーションモデルをSQLデータベーススã‚ーマã¸å¤‰æ›ã™ã‚‹ã¨ãã® ã™ã¹ã¦ã®å•é¡Œã«ã†ã¾ã対処ã§ãã¾ã™ã€‚ 覚ãˆã¦ãŠã‹ãªã‘ã‚Œã°ãªã‚‰ãªã„ルールã¯ç°¡å˜ã§ã™ã€‚ åŒæ–¹å‘関連ã¯å¿…ã!
šç‰‡å´ã‚’ <literal>inverse</literal> ã«ã™ã‚‹å¿…è¦ãŒã‚ã‚‹ã¨ã„ã†ã“ã¨ã§ã™ã€‚ 一対多関連ã§ã¯ãã‚Œã¯å¤šå´ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。 多対多関連ã§ã¯ã©ã¡ã‚‰å´ã§ã‚‚構ã„ã¾ã›ã‚“。ã©ã¡ã‚‰ã§ã‚‚é•ã„ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr "ã§ã¯ã“れをå°ã•ãªWebアプリケーションã«ã—ã¦ã¿ã¾ã—ょã†ã€‚"
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr "パート3 - EventManager Webアプリケーション"
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr "Hibernateã®Webアプリケーションã¯ã€ã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ¼ãƒ³ã®ã‚¢ãƒ—リケーションã®ã‚ˆã†ã« <literal>Session</literal> 㨠<literal>Transaction</literal> を使用ã—ã¾ã™ã€‚ ã—ã‹ã—ã„ãã¤ã‹ã®ä¸€èˆ¬çš„ãªãƒ‘ターンãŒå½¹ç«‹ã¡ã¾ã™ã€‚ ã“ã“㧠<literal>EventManagerServlet</literal> を作æˆã—ã¾ã™ã€‚ã“ã®ã‚µãƒ¼ãƒ–レットã¯ã€ データベースã«æ ¼ç´ã—ãŸå…¨ã¦ã®ã‚¤ãƒ™ãƒ³ãƒˆã‚’リストã«ã§ãã€ã•ã‚‰ã«HTMLフォームã‹ã‚‰æ–°ã—ã„イベントを入力ã§ãã‚‹ã‚‚ã®ã§ã™ã€‚"
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr "基本的ãªServletã®è¨˜è¿°"
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr "æ–°ã—ã„クラスをã€ã‚½ãƒ¼ã‚¹ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã® <literal>events</literal> パッケージã«ä½œæˆã—ã¦ãã ã•ã„。"
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr ""
+ "<![CDATA[package events;
+\n"
+ "
+\n"
+ "// Imports
+\n"
+ "
+\n"
+ "public class EventManagerServlet extends HttpServlet {
+\n"
+ "
+\n"
+ " // Servlet code
+\n"
+ "}]]>"
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr "Servletã¯HTTPã® <literal>GET</literal> リクエストã®ã¿ã‚’処ç†ã™ã‚‹ã®ã§ã€ <literal>doGet()</literal> を実装ã—ã¾ã™ã€‚"
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,
+\n"
+ " HttpServletResponse response)
+\n"
+ " throws ServletException, IOException {
+\n"
+ "
+\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");
+\n"
+ "
+\n"
+ " try {
+\n"
+ " // Begin unit of work
+\n"
+ " HibernateUtil.getSessionFactory()
+\n"
+ " .getCurrentSession().beginTransaction();
+\n"
+ "
+\n"
+ " // Process request and render page...
+\n"
+ "
+\n"
+ " // End unit of work
+\n"
+ " HibernateUtil.getSessionFactory()
+\n"
+ " .getCurrentSession().getTransaction().commit();
+\n"
+ "
+\n"
+ " } catch (Exception ex) {
+\n"
+ " HibernateUtil.getSessionFactory()
+\n"
+ " .getCurrentSession().getTransaction().rollback();
+\n"
+ " throw new ServletException(ex);
+\n"
+ " }
+\n"
+ "
+\n"
+ "}]]>"
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr "ã“れ㯠<emphasis>session-per-request</emphasis> ã¨ã„ã†ãƒ‘ターンã§ã™ã€‚ ServletãŒãƒªã‚¯ã‚¨ã‚¹ãƒˆã‚’å—ã‘å–ã‚‹ã¨ã€ <literal>SessionFactory</literal> ã® <literal>getCurrentSession()</literal> ã®æœ€åˆã®å‘¼ã³å‡ºã—ã§ã€ Hibernateã®æ–°ã—ã„ <literal>Session</literal> ãŒé–‹ã‹ã‚Œã¾ã™ã€‚ ãã®ã¨ãデータベーストランザクションãŒé–‹å§‹ã•ã‚Œã¾ã™ã€‚ データã®èªã¿æ›¸ãã«é–¢ã‚らãšã€ã™ã¹ã¦ã®ãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹ã¯ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å†…ã§è¡Œã„ã¾ã™ã€‚ （アプリケーション内ã§ã¯ã‚ªãƒ¼ãƒˆã‚³ãƒŸãƒƒãƒˆãƒ¢ãƒ¼ãƒ‰ã‚’使用ã—ã¾ã›ã‚“）。"
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "次ã«ã€ãƒªã‚¯ã‚¨ã‚¹ãƒˆã®ã‚¢ã‚¯ã‚·ãƒ§ãƒ³ã¯å‡¦ç†ã•ã‚Œã€ãƒ¬ã‚¹ãƒãƒ³ã‚¹ã§ã‚ã‚‹HTMLãŒæç”»ã•ã‚Œã¾ã™ã€‚ ã“ã‚Œã«ã¤ã„ã¦ã¯ã™ãã«èª¬æ˜Žã—ã¾ã™ã€‚"
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr "最後ã«ãƒªã‚¯ã‚¨ã‚¹ãƒˆã®å‡¦ç†ã¨HTMLæç”»ãŒå®Œäº†ã—ãŸã¨ãã«ã€ä½œæ¥å˜ä½(Unit of Work)を終了ã—ã¾ã™ã€‚ ã‚‚ã—処ç†ã‚„æç”»ä¸ã«å•é¡ŒãŒç™ºç”Ÿã—ãŸå ´åˆã€exceptionãŒæŠ•ã’られã¦ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³ã‚’ãƒãƒ¼ãƒ«ãƒãƒƒã‚¯ã—ã¾ã™ã€‚ ã“れ㧠<literal>session-per-request</literal> パターンãŒå®Œäº†ã—ã¾ã™ã€‚ å…¨ã¦ã®ã‚µãƒ¼ãƒ–レットã«ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å¢ƒç•Œã®ã‚³ãƒ¼ãƒ‰ã‚’書ã代ã‚ã‚Šã«ã€ã‚µãƒ¼ãƒ–レットフィルタã«è¨˜è¿°ã™ã‚‹ã“ã¨ã‚‚å¯èƒ½ã§ã™ã€‚ <emphasis>Open Session in View</emphasis> ã¨å‘¼ã°ã‚Œã‚‹ã“ã®ãƒ‘ターンã«ã¤ã„ã¦ã¯ã€ Hibernateã®WebサイトやWikiã‚’å‚ç…§ã—ã¦ãã ã•ã„。 サーブレットã§ã¯ãªãJSPã§HTMLæ画をã—よã†ã¨ã™ã‚‹ã¨ã€ã™ãã«ã“ã®ãƒ‘ターンã«ã¤ã„ã¦ã®æƒ…å ±ãŒå¿…è¦ã«ãªã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr "処ç†ã¨æç”»"
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr "ã§ã¯ã€ãƒªã‚¯ã‚¨ã‚¹ãƒˆã®å‡¦ç†ã¨ãƒšãƒ¼ã‚¸ã®æ画を実装ã—ã¾ã™ã€‚"
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr ""
+ "<![CDATA[// Write HTML header
+\n"
+ "PrintWriter out = response.getWriter();
+\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");
+\n"
+ "
+\n"
+ "// Handle actions
+\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {
+\n"
+ "
+\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");
+\n"
+ " String eventDate = request.getParameter(\"eventDate\");
+\n"
+ "
+\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {
+\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");
+\n"
+ " } else {
+\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));
+\n"
+ " out.println(\"<b><i>Added event.</i></b>\");
+\n"
+ " }
+\n"
+ "}
+\n"
+ "
+\n"
+ "// Print page
+\n"
+ "printEventForm(out);
+\n"
+ "listEvents(out, dateFormatter);
+\n"
+ "
+\n"
+ "// Write HTML footer
+\n"
+ "out.println(\"</body></html>\");
+\n"
+ "out.flush();
+\n"
+ "out.close();]]>"
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr "Javaã¨HTMLãŒæ··åœ¨ã™ã‚‹ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°ã‚¹ã‚¿ã‚¤ãƒ«ã¯ã€ã‚ˆã‚Šè¤‡é›‘ãªã‚¢ãƒ—リケーションã«ã¯é©ã—ã¦ã„ãªã„ã§ã—ょㆠ（ã“ã®ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã§ã¯ã€åŸºæœ¬çš„ãªHibernateã®ã‚³ãƒ³ã‚»ãƒ—トを示ã—ã¦ã„ã‚‹ã ã‘ã§ã‚ã‚‹ã“ã¨ã‚’覚ãˆã¦ãŠã„ã¦ãã ã•ã„）。 ã“ã®ã‚³ãƒ¼ãƒ‰ã¯HTMLã®ãƒ˜ãƒƒãƒ€ãƒ¼ã¨ãƒ•ãƒƒã‚¿ãƒ¼ã®è¨˜è¿°ã§ã™ã€‚ ã“ã®ãƒšãƒ¼ã‚¸ã«ã¯ã€ã‚¤ãƒ™ãƒ³ãƒˆã‚’入力ã™ã‚‹HTMLフォームã¨ã€ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã«ã‚ã‚‹å…¨ã¦ã®ã‚¤ãƒ™ãƒ³ãƒˆã®ãƒªã‚¹ãƒˆãŒè¡¨ç¤ºã•ã‚Œã¾ã™ã€‚ 最åˆã®ãƒ¡ã‚½ãƒƒãƒ‰ã¯ã”ãå˜ç´”ãªHTML出力ã§ã™ã€‚"
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {
+\n"
+ " out.println(\"<h2>Add new event:</h2>\");
+\n"
+ " out.println(\"<form>\");
+\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");
+\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");
+\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");
+\n"
+ " out.println(\"</form>\");
+\n"
+ "}]]>"
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr "<literal>listEvents()</literal> メソッドã¯ã€ç¾åœ¨ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã«çµã³ã¤ã Hibernateã® <literal>Session</literal> を使用ã—ã¦ã€ã‚¯ã‚¨ãƒªã‚’実行ã—ã¾ã™ã€‚"
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {
+\n"
+ "
+\n"
+ " List result = HibernateUtil.getSessionFactory()
+\n"
+ " .getCurrentSession().createCriteria(Event.class).list();
+\n"
+ " if (result.size() > 0) {
+\n"
+ " out.println(\"<h2>Events in database:</h2>\");
+\n"
+ " out.println(\"<table border='1'>\");
+\n"
+ " out.println(\"<tr>\");
+\n"
+ " out.println(\"<th>Event title</th>\");
+\n"
+ " out.println(\"<th>Event date</th>\");
+\n"
+ " out.println(\"</tr>\");
+\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {
+\n"
+ " Event event = (Event) it.next();
+\n"
+ " out.println(\"<tr>\");
+\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");
+\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");
+\n"
+ " out.println(\"</tr>\");
+\n"
+ " }
+\n"
+ " out.println(\"</table>\");
+\n"
+ " }
+\n"
+ "}]]>"
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr "最後ã«ã€ <literal>store</literal> アクション㌠<literal>createAndStoreEvent()</literal> メソッドを 呼ã³å‡ºã—ã¾ã™ã€‚ã“ã®ãƒ¡ã‚½ãƒƒãƒ‰ã§ã‚‚ç¾åœ¨ã®ã‚¹ãƒ¬ãƒƒãƒ‰ã® <literal>Session</literal> を利用ã—ã¾ã™ã€‚"
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {
+\n"
+ " Event theEvent = new Event();
+\n"
+ " theEvent.setTitle(title);
+\n"
+ " theEvent.setDate(theDate);
+\n"
+ "
+\n"
+ " HibernateUtil.getSessionFactory()
+\n"
+ " .getCurrentSession().save(theEvent);
+\n"
+ "}]]>"
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr "ã“ã‚Œã§ã‚µãƒ¼ãƒ–レットã®å®Œæˆã§ã™ã€‚ サーブレットã¸ã®ãƒªã‚¯ã‚¨ã‚¹ãƒˆã¯ã€ä¸€ã¤ã® <literal>Session</literal> 㨠<literal>Transaction</literal> ã§å‡¦ç†ã•ã‚Œã‚‹ã§ã—ょã†ã€‚ 最åˆã®ã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ¼ãƒ³ã®ã‚¢ãƒ—リケーションã®ã‚ˆã†ã«ã€ Hibernateã¯è‡ªå‹•çš„ã«ã“れらã®ã‚ªãƒ–ジェクトを実行ã™ã‚‹ã‚¹ãƒ¬ãƒƒãƒ‰ã«çµã³ä»˜ã‘ã‚‹ã“ã¨ãŒã§ãã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚Šã€é–‹ç™ºè€…ãŒè‡ªç”±ã«ã‚³ãƒ¼ãƒ‰ã‚’レイヤー分ã‘ã§ã〠好ããªæ–¹æ³•ã§ <literal>SessionFactory</literal> ã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ãŒã§ãるよã†ã«ãªã‚Šã¾ã™ã€‚ 通常ã€é–‹ç™ºè€…ã¯ã‚ˆã‚Šæ´—ç·´ã•ã‚ŒãŸãƒ‡ã‚¶ã‚¤ãƒ³ã‚’使用ã—ã¦ã€ãƒ‡ãƒ¼ã‚¿ã‚¢ã‚¯ã‚»ã‚¹ã®ã‚³ãƒ¼ãƒ‰ã‚’ データアクセスオブジェクトã«ç§»å‹•ã™ã‚‹ã§ã—ょã†ï¼ˆDAOパターン）。 より多ãã®ä¾‹ã¯ã€Hibernateã®Wikiã‚’å‚ç…§ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr "デプãƒã‚¤ã¨ãƒ†ã‚¹ãƒˆ"
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr "ã“ã®ã‚¢ãƒ—リケーションã®ãƒ‡ãƒ—ãƒã‚¤ã®ãŸã‚ã«ã€Webアーカイブ（WAR）を作æˆã—ã¦ãã ã•ã„。 以下ã®Antターゲットを <literal>build.xml</literal> ã«åŠ ãˆã¦ãã ã•ã„。"
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">
+\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">
+\n"
+ " <lib dir=\"${librarydir}\">
+\n"
+ " <exclude name=\"jsdk*.jar\"/>
+\n"
+ " </lib>
+\n"
+ "
+\n"
+ " <classes dir=\"${targetdir}\"/>
+\n"
+ " </war>
+\n"
+ "</target>]]>"
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr "ã“ã®ã‚¿ãƒ¼ã‚²ãƒƒãƒˆã¯ <literal>hibernate-tutorial.war</literal> ã¨ã„ã†ãƒ•ã‚¡ã‚¤ãƒ«ã‚’ プãƒã‚¸ã‚§ã‚¯ãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«ä½œæˆã—ã¾ã™ã€‚ ã“ã®ãƒ•ã‚¡ã‚¤ãƒ«ã¯ã™ã¹ã¦ã®ãƒ©ã‚¤ãƒ–ラリ㨠<literal>web.xml</literal> 記述åã‚’å«ã‚“ã§ãŠã‚Šã€ プãƒã‚¸ã‚§ã‚¯ãƒˆã®ãƒ™ãƒ¼ã‚¹ãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã«ç½®ã‹ã‚Œã‚‹ã“ã¨ã‚’期待ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+\n"
+ "<web-app version=\"2.4\"
+\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"
+\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
+\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">
+\n"
+ "
+\n"
+ " <servlet>
+\n"
+ " <servlet-name>Event Manager</servlet-name>
+\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>
+\n"
+ " </servlet>
+\n"
+ "
+\n"
+ " <servlet-mapping>
+\n"
+ " <servlet-name>Event Manager</servlet-name>
+\n"
+ " <url-pattern>/eventmanager</url-pattern>
+\n"
+ " </servlet-mapping>
+\n"
+ "</web-app>]]>"
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr "Webアプリケーションã®ã‚³ãƒ³ãƒ‘イルã¨ãƒ‡ãƒ—ãƒã‚¤ã®å‰ã«ã€ <literal>jsdk.jar</literal> ã¨ã„ã† è¿½åŠ ã®ãƒ©ã‚¤ãƒ–ラリãŒå¿…è¦ãªã“ã¨ã«æ³¨æ„ã—ã¦ãã ã•ã„。 ã“ã‚Œã¯Javaサーブレットã®é–‹ç™ºã‚ットã§ã™ã€‚ ã‚‚ã—ã¾ã ã“ã®ãƒ©ã‚¤ãƒ–ラリをæŒã£ã¦ã„ãªã„ãªã‚‰ã€Sunã®ã‚¦ã‚§ãƒ–サイトã§å…¥æ‰‹ã—ã¦ã€ ライブラリディレクトリã«ã‚³ãƒ”ーã—ã¦ãã ã•ã„。 ã—ã‹ã—ã€ã“ã‚Œã¯ã‚³ãƒ³ãƒ‘イルã«ã®ã¿ä½¿ç”¨ã•ã‚Œã€WARパッケージã‹ã‚‰ã¯é™¤å¤–ã•ã‚Œã¾ã™ã€‚"
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr "ビルドã¨ãƒ‡ãƒ—ãƒã‚¤ã®ãŸã‚ã«ã€ãƒ—ãƒã‚¸ã‚§ã‚¯ãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã§ <literal>ant war</literal> を呼ã³å‡ºã—〠<literal>hibernate-tutorial.war</literal> ファイルをTomcatã® <literal>webapp</literal> ディレクトリã«ã‚³ãƒ”ーã—ã¦ãã ã•ã„。 ã¾ã Tomcatをインストールã—ã¦ã„ãªã‘ã‚Œã°ã€ãƒ€ã‚¦ãƒ³ãƒãƒ¼ãƒ‰ã—ã¦ã€ä»¥ä¸‹ã®ã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«ã‚¬ã‚¤ãƒ‰ã«å¾“ã£ã¦ãã ã•ã„。 ã—ã‹ã—ã€ã“ã®ã‚¢ãƒ—リケーションã®ãƒ‡ãƒ—ãƒã‚¤ã™ã‚‹ãŸã‚ã«ã€Tomcatã®è¨å®šã‚’変更ã™ã‚‹å¿…è¦ã¯ã‚ã‚Šã¾ã›ã‚“。"
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr "一度デプãƒã‚¤ã—ã¦Tomcatã‚’èµ·å‹•ã™ã‚Œã°ã€ <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal> 㧠アプリケーションã¸ã®ã‚¢ã‚¯ã‚»ã‚¹ãŒå¯èƒ½ã§ã™ã€‚ 最åˆã®ãƒªã‚¯ã‚¨ã‚¹ãƒˆãŒä½œæˆã—ãŸã‚µãƒ¼ãƒ–レットã«æ¸¡ã£ãŸã¨ãã«ã€Tomcatã®ãƒã‚°ã§ Hibernateã®åˆæœŸåŒ–処ç†ã‚’確èªã—ã¦ãã ã•ã„ （ <literal>HibernateUtil</literal> 内ã®é™çš„åˆæœŸåŒ–ブãƒãƒƒã‚¯ãŒå‘¼ã°ã‚Œã¦ã„ã¾ã™ï¼‰ã€‚ ã¾ãŸã€exceptionãŒç™ºç”Ÿã—ãŸãªã‚‰è©³ç´°ã‚’確èªã—ã¦ãã ã•ã„。"
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr "<title>è¦ç´„</title>"
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr "ã“ã®ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ã§ã¯ã€ç°¡å˜ãªã‚¹ã‚¿ãƒ³ãƒ‰ã‚¢ãƒãƒ¼ãƒ³ã®Hibernateアプリケーション㨠å°è¦æ¨¡ã®Webアプリケーションを書ããŸã‚ã®åŸºæœ¬ã‚’紹介ã—ã¾ã—ãŸã€‚"
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr "ã‚‚ã†Hibernateã«è‡ªä¿¡ãŒã‚ã‚Œã°ã€ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹ãƒ‰ã‚ュメントã®ç›®æ¬¡ã«ç›®ã‚’通ã—ã¦ã€ é¢ç™½ãã†ã ã¨æ€ã†ãƒˆãƒ”ックを探ã—ã¦ãã ã•ã„。 æœ€ã‚‚é »ç¹ã«è³ªå•ãŒã‚ã‚‹ã®ã¯ã€ãƒˆãƒ©ãƒ³ã‚¶ã‚¯ã‚·ãƒ§ãƒ³å‡¦ç†ï¼ˆ<xref linkend=\"transactions\"/>）〠フェッãƒã®ãƒ‘フォーマンス（<xref linkend=\"performance\"/>）〠APIã®ä½¿ã„方（<xref linkend=\"objectstate\"/>）ã¨ã‚¯ã‚¨ãƒª （<xref linkend=\"objectstate-querying\"/>）ã§ã™ã€‚"
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr "ã•ã‚‰ã«ï¼ˆç‰¹åˆ¥ãªï¼‰ãƒãƒ¥ãƒ¼ãƒˆãƒªã‚¢ãƒ«ãŒå¿…è¦ãªã‚‰ã€Hibernateウェブサイトを忘れãšã«ãƒã‚§ãƒƒã‚¯ã—ã¦ãã ã•ã„。"
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,549 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr "XMLマッピング"
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr "XMLマッピングã¯Hibernate3.0ã§ã¯è©¦é¨“çš„ãªæ©Ÿèƒ½ã§ã‚ã‚Šã€éžå¸¸ã«æ´»å‹•çš„ã«é–‹ç™ºä¸ã§ã™ã€‚"
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr "XMLデータã§ã®ä½œæ¥"
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr "Hibernateã§ã¯æ°¸ç¶šæ€§ã®POJOを使ã£ã¦ä½œæ¥ã™ã‚‹ã®ã¨ã»ã¼åŒã˜ã‚ˆã†ãªã‚„ã‚Šæ–¹ã§ã€ 永続性ã®XMLデータを使ã£ã¦ä½œæ¥ã§ãã¾ã™ã€‚"
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr "Hibernateã¯XMLツリーをæ“作ã™ã‚‹ãŸã‚ã®APIã¨ã—ã¦dom4jをサãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã™ã€‚ データベースã‹ã‚‰dom4jã®ãƒ„リーを復元ã™ã‚‹ã‚¯ã‚¨ãƒªã‚’書ãã“ã¨ãŒã§ã〠ツリーã«å¯¾ã—ã¦è¡Œã£ãŸä¿®æ£ã¯è‡ªå‹•çš„ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¨åŒæœŸã•ã‚Œã¾ã™ã€‚ ã¾ãŸXMLドã‚ュメントをå–å¾—ã™ã‚‹ã“ã¨ãŒã§ãã€dom4jを使ã£ã¦ãƒ‰ã‚ュメントをパースã—〠Hibernateã®ä»»æ„ã®åŸºæœ¬æ“作を使ã£ã¦ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¸æ›¸ã込むã“ã¨ãŒã§ãã¾ã™ã€‚： ã¤ã¾ã‚Šã€<literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> æ“作ã§ã™(マージã¯ã¾ã サãƒãƒ¼ãƒˆã—ã¦ã„ã¾ã›ã‚“)。"
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr "データã®ã‚¤ãƒ³ãƒãƒ¼ãƒˆ/エクスãƒãƒ¼ãƒˆã€ JMSã«ã‚ˆã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ãƒ‡ãƒ¼ã‚¿ã®å¤–部化やSOAPã€XSLTベースã®ãƒ¬ãƒãƒ¼ãƒˆãªã©ã€ ã“ã®æ©Ÿèƒ½ã«ã¯å¤šãã®ç”¨é€”ãŒã‚ã‚Šã¾ã™ã€‚"
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr "å˜ä¸€ã®ãƒžãƒƒãƒ”ングã¯ã€ã‚¯ãƒ©ã‚¹ã®ãƒ—ãƒãƒ‘ティã¨XMLドã‚ュメントã®ãƒŽãƒ¼ãƒ‰ã‚’ åŒæ™‚ã«ãƒ‡ãƒ¼ã‚¿ãƒ™ãƒ¼ã‚¹ã¸ãƒžãƒƒãƒ”ングã™ã‚‹ãŸã‚ã«ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚ ã¾ãŸãƒžãƒƒãƒ”ングã™ã‚‹ã‚¯ãƒ©ã‚¹ãŒãªã‘ã‚Œã°ã€ XMLã ã‘をマッピングã™ã‚‹ãŸã‚ã«ä½¿ã†ã“ã¨ãŒã§ãã¾ã™ã€‚"
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr "XMLã¨ã‚¯ãƒ©ã‚¹ã®ãƒžãƒƒãƒ”ングをåŒæ™‚ã«æŒ‡å®šã™ã‚‹"
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr "ã“ã‚Œã¯POJOã¨XMLã‚’åŒæ™‚ã«ãƒžãƒƒãƒ”ングã™ã‚‹ä¾‹ã§ã™ã€‚："
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Account\"
+\n"
+ " table=\"ACCOUNTS\"
+\n"
+ " node=\"account\">
+\n"
+ "
+\n"
+ " <id name=\"accountId\"
+\n"
+ " column=\"ACCOUNT_ID\"
+\n"
+ " node=\"@id\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"customer\"
+\n"
+ " column=\"CUSTOMER_ID\"
+\n"
+ " node=\"customer/@id\"
+\n"
+ " embed-xml=\"false\"/>
+\n"
+ "
+\n"
+ " <property name=\"balance\"
+\n"
+ " column=\"BALANCE\"
+\n"
+ " node=\"balance\"/>
+\n"
+ "
+\n"
+ " ...
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr "XMLマッピングã ã‘を指定ã™ã‚‹"
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr "ã“ã‚Œã¯POJOクラスãŒãªã„マッピングã®ä¾‹ã§ã™ã€‚："
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class entity-name=\"Account\"
+\n"
+ " table=\"ACCOUNTS\"
+\n"
+ " node=\"account\">
+\n"
+ "
+\n"
+ " <id name=\"id\"
+\n"
+ " column=\"ACCOUNT_ID\"
+\n"
+ " node=\"@id\"
+\n"
+ " type=\"string\"/>
+\n"
+ "
+\n"
+ " <many-to-one name=\"customerId\"
+\n"
+ " column=\"CUSTOMER_ID\"
+\n"
+ " node=\"customer/@id\"
+\n"
+ " embed-xml=\"false\"
+\n"
+ " entity-name=\"Customer\"/>
+\n"
+ "
+\n"
+ " <property name=\"balance\"
+\n"
+ " column=\"BALANCE\"
+\n"
+ " node=\"balance\"
+\n"
+ " type=\"big_decimal\"/>
+\n"
+ "
+\n"
+ " ...
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr "ã“ã®ãƒžãƒƒãƒ”ングã«ã‚ˆã‚Šã€dom4jツリーã‹ã€ プãƒãƒ‘ティå/値ã®çµ„ã®ã‚°ãƒ©ãƒ•ï¼ˆjavaã® <literal>Map</literal>）ã¨ã—㦠データã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã™ã€‚ プãƒãƒ‘ティã®åå‰ã¯ã€HQLクエリー内ã§å‚ç…§ã§ãる純粋ãªè«–ç†æ§‹é€ ã§ã™ã€‚"
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr "XMLマッピングã®ãƒ¡ã‚¿ãƒ‡ãƒ¼ã‚¿"
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr "多ãã®Hibernateã®ãƒžãƒƒãƒ”ングè¦ç´ ã¯ã€€<literal>node</literal>　属性ãŒä½¿ç”¨ã§ãã¾ã™ã€‚ ã“ã‚Œã«ã‚ˆã‚ŠXML属性ã®åå‰ã‚„プãƒãƒ‘ティやエンティティデータをä¿æŒã™ã‚‹è¦ç´ を指定ã§ãã¾ã™ã€‚ <literal>node</literal>　属性ã®ãƒ•ã‚©ãƒ¼ãƒžãƒƒãƒˆã¯ä»¥ä¸‹ã®ä¸ã®1ã¤ã§ãªã‘ã‚Œã°ãªã‚Šã¾ã›ã‚“。："
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr "<literal>\"element-name\"</literal> - 指定ã—ãŸXMLè¦ç´ ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™"
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr "<literal>\"@attribute-name\"</literal> - 指定ã—ãŸXML属性ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™"
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr "<literal>\".\"</literal> -　親è¦ç´ ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™"
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr "<literal>\"element-name/@attribute-name\"</literal> - 指定ã—ãŸã‚¨ãƒ¬ãƒ¡ãƒ³ãƒˆã®æŒ‡å®šã—ãŸå±žæ€§ã¸ãƒžãƒƒãƒ”ングã—ã¾ã™"
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr "コレクションã¨å˜ä¸€ã®å€¤ã®é–¢é€£ã«å¯¾ã—ã¦ã€ ãŠã¾ã‘ã® <literal>embed-xml</literal> 属性ãŒã‚ã‚Šã¾ã™ã€‚ デフォルト㮠<literal>embed-xml=\"true\"</literal> ã¨è¨å®šã—ãŸå ´åˆã€ 関連ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£(値型ã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³)ã®XMLツリーã¯ã€ 直接関連を所有ã™ã‚‹ã‚¨ãƒ³ãƒ†ã‚£ãƒ†ã‚£ã®XMLツリー内ã«åŸ‹ã‚è¾¼ã¾ã‚Œã¾ã™ã€‚ å対ã«ã€<literal>embed-xml=\"false\"</literal> ã¨è¨å®šã—ãŸå ´åˆã€ å‚ç…§ã•ã‚Œã‚‹è˜åˆ¥åã®å€¤ã ã‘ãŒå¤šé‡åº¦ï¼‘å´ã®é–¢é€£ã«å¯¾ã™ã‚‹XMLã«ç¾ã‚Œã€ å˜ç´”ã«ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã¯ã¾ã£ãŸãç¾ã‚Œãªããªã‚Šã¾ã™ã€‚"
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr "ã‚ã¾ã‚Šã«å¤šãã®é–¢é€£ã«å¯¾ã—㦠<literal>embed-xml=\"true\"</literal> ã¨ã—ãŸã¾ã¾ã«ã™ã‚‹ã®ã¯æ³¨æ„ã™ã¹ãã§ã™ã€‚ XMLã¯å¾ªç’°ã‚’ã†ã¾ã扱ãˆã¾ã›ã‚“。"
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\"
+\n"
+ " table=\"CUSTOMER\"
+\n"
+ " node=\"customer\">
+\n"
+ "
+\n"
+ " <id name=\"id\"
+\n"
+ " column=\"CUST_ID\"
+\n"
+ " node=\"@id\"/>
+\n"
+ "
+\n"
+ " <map name=\"accounts\"
+\n"
+ " node=\".\"
+\n"
+ " embed-xml=\"true\">
+\n"
+ " <key column=\"CUSTOMER_ID\"
+\n"
+ " not-null=\"true\"/>
+\n"
+ " <map-key column=\"SHORT_DESC\"
+\n"
+ " node=\"@short-desc\"
+\n"
+ " type=\"string\"/>
+\n"
+ " <one-to-many entity-name=\"Account\"
+\n"
+ " embed-xml=\"false\"
+\n"
+ " node=\"account\"/>
+\n"
+ " </map>
+\n"
+ "
+\n"
+ " <component name=\"name\"
+\n"
+ " node=\"name\">
+\n"
+ " <property name=\"firstName\"
+\n"
+ " node=\"first-name\"/>
+\n"
+ " <property name=\"initial\"
+\n"
+ " node=\"initial\"/>
+\n"
+ " <property name=\"lastName\"
+\n"
+ " node=\"last-name\"/>
+\n"
+ " </component>
+\n"
+ "
+\n"
+ " ...
+\n"
+ "
+\n"
+ "</class>]]>"
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr "ã“ã®ä¾‹ã§ã¯ã€å®Ÿéš›ã®accountã®ãƒ‡ãƒ¼ã‚¿ã§ã¯ãªã〠accountã®idã®ã‚³ãƒ¬ã‚¯ã‚·ãƒ§ãƒ³ã‚’埋ã‚込むã“ã¨ã«ã—ã¾ã—ãŸã€‚ 続ãã®HQLクエリã§ã™ï¼š"
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr "ã“ã®ã‚ˆã†ãªãƒ‡ãƒ¼ã‚¿ã‚»ãƒƒãƒˆã‚’è¿”ã™ã§ã—ょã†"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">
+\n"
+ " <account short-desc=\"Savings\">987632567</account>
+\n"
+ " <account short-desc=\"Credit Card\">985612323</account>
+\n"
+ " <name>
+\n"
+ " <first-name>Gavin</first-name>
+\n"
+ " <initial>A</initial>
+\n"
+ " <last-name>King</last-name>
+\n"
+ " </name>
+\n"
+ " ...
+\n"
+ "</customer>]]>"
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr "<literal><one-to-many></literal> マッピング㧠<literal>embed-xml=\"true\"</literal> ã¨è¨å®šã—ãŸå ´åˆã€ データã¯ã“ã®ã‚ˆã†ã«ãªã‚‹ã§ã—ょã†ã€‚"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">
+\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">
+\n"
+ " <customer id=\"123456789\"/>
+\n"
+ " <balance>100.29</balance>
+\n"
+ " </account>
+\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">
+\n"
+ " <customer id=\"123456789\"/>
+\n"
+ " <balance>-2370.34</balance>
+\n"
+ " </account>
+\n"
+ " <name>
+\n"
+ " <first-name>Gavin</first-name>
+\n"
+ " <initial>A</initial>
+\n"
+ " <last-name>King</last-name>
+\n"
+ " </name>
+\n"
+ " ...
+\n"
+ "</customer>]]>"
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr "XMLデータを扱ã†"
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr "XMLドã‚ュメントをã€ã‚¢ãƒ—リケーション内ã§å†èªã¿è¾¼ã¿ã‚„æ›´æ–°ã‚’ã—ã¦ã¿ã¾ã—ょã†ã€‚ 以下ã§ã¯dom4jã®ã‚»ãƒƒã‚·ãƒ§ãƒ³ã‚’å–å¾—ã™ã‚‹ã“ã¨ã§è¡Œã„ã¾ã™ã€‚："
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Document doc = ....;
+\n"
+ "
+\n"
+ "Session session = factory.openSession();
+\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "List results = dom4jSession
+\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")
+\n"
+ " .list();
+\n"
+ "for ( int i=0; i<results.size(); i++ ) {
+\n"
+ " //add the customer data to the XML document
+\n"
+ " Element customer = (Element) results.get(i);
+\n"
+ " doc.getRootElement().add(customer);
+\n"
+ "}
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = factory.openSession();
+\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);
+\n"
+ "Transaction tx = session.beginTransaction();
+\n"
+ "
+\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);
+\n"
+ "for ( int i=0; i<results.size(); i++ ) {
+\n"
+ " Element customer = (Element) results.get(i);
+\n"
+ " //change the customer name in the XML and database
+\n"
+ " Element name = customer.element(\"name\");
+\n"
+ " name.element(\"first-name\").setText(firstName);
+\n"
+ " name.element(\"initial\").setText(initial);
+\n"
+ " name.element(\"last-name\").setText(lastName);
+\n"
+ "}
+\n"
+ "
+\n"
+ "tx.commit();
+\n"
+ "session.close();]]>"
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr "XMLベースã®ãƒ‡ãƒ¼ã‚¿ã®ã‚¤ãƒ³ãƒãƒ¼ãƒˆ/エクスãƒãƒ¼ãƒˆã‚’実装ã™ã‚‹ãŸã‚ã«ã€ Hibernateã® <literal>replicate()</literal> æ“作をã“ã®æ©Ÿèƒ½ã‚’çµã³ã¤ã‘ã‚‹ã®ã¯ 極ã‚ã¦æœ‰åŠ¹ã§ã™ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ja-JP/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/ja-JP/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/ja-JP/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - 개성있는 ìžë°”를 위한 관계 ì˜ì†"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "하ì´ë²„네ì´íŠ¸ 참조 문서"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr "아키í…처"
+
+#: index.docbook:24
+msgid "Overview"
+msgstr "<title>개요</title>"
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr "Hibernate 아키í…ì²˜ì— ëŒ€í•œ (매우) ë†’ì€ ìˆ˜ì¤€ì˜ ê°œìš”::"
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr "ì´ ë‹¤ì´ì–´ê·¸ëž¨ì€ 어플리케ì´ì…˜ì— ì˜ì†í™” 서비스들(ê³¼ ì˜ì† ê°ì²´ë“¤)ì„ ì œê³µí•˜ê¸° 위해 ë°ì´í„°ë² ì´ìŠ¤ì™€ ì»¨í”¼ê·¸ë ˆì´ì…˜ì„ 사용하는 Hibernate를 보여준다."
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 "우리는 런타임 아키í…ì²˜ì— ëŒ€í•œ 보다 ìƒì„¸í•œ 뷰를 ë³´ì—¬ì£¼ê³ ì‹¶ë‹¤. 불행하게ë„, Hibernate는 ìœ ì—°í•˜ë©° 몇 가지 ì ‘ê·¼ë²•ë“¤ì„ ì œê³µí•œë‹¤. 우리는 ë‘ ê°€ì§€ ê·¹ë‹¨ì„ ë³´ì—¬ì¤„ 것ì´ë‹¤. \"경량급\" 아키í…처는 그것 ìžì‹ ì˜ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì œê³µí•˜ê³ ê·¸ê²ƒ ìžì‹ ì˜ íŠ¸ëžœìžì…˜ë“¤ì„ 관리하는 어플리케ì´ì…˜ì„ 갖는다. ì´ ì ‘ê·¼ë²•ì€ Hibernateì˜ APIì˜ ìµœì†Œ ë¶€ë¶„ì§‘í•©ì„ ì‚¬ìš©í•œë‹¤:"
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr "\"ì „ì²´ ì •ìˆ˜\" 아키í…처는 기본 JDBC/JTA로부터 어플리케ì´ì…˜ì„ 추ìƒí™” ì‹œí‚¤ê³ Hibernateë¡œ 하여금 ìƒì„¸í•œ ê²ƒì„ ì²˜ë¦¬í•˜ê²Œ 한다."
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr "다ìŒì€ 다ì´ì–´ê·¸ëž¨ë“¤ ë‚´ì— ìžˆëŠ” ê°ì²´ë“¤ì— 대한 몇가지 ì •ì˜ë“¤ì´ë‹¤:"
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr "ë‹¨ì¼ ë°ì´í„°ë² ì´ìŠ¤ì— 대한 컴파ì¼ëœ ë§¤í•‘ë“¤ì˜ threadsafe (불변ì˜) ìºì‹œ. Sessionê³¼ ConnectionProviderì˜ í´ë¼ì´ì–¸íŠ¸ë¥¼ 위한 íŒ©í† ë¦¬. 프로세스 ë ˆë²¨ ë˜ëŠ” í´ëŸ¬ìŠ¤í„° ë ˆë²¨ì—ì„œ 트랜ìžì…˜ë“¤ 사ì´ì— 재사용 가능한 ë°ì´í„°ì˜ ì„ íƒì ì¸ (second-level) ìºì‹œë¥¼ ë³´ê´€í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr "Session (<literal>org.hibernate.Session</literal>)"
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr "어플리케ì´ì…˜ê³¼ ì˜ì† ì €ìž¥ì†Œ 사ì´ì˜ 대화를 표현하는 ë‹¨ì¼ ì“°ë ˆë“œì´ê³ , ìˆ˜ëª…ì´ ì§§ì€ ê°ì²´. JDBC ì»¤ë„¥ì…˜ì„ í¬ìž¥í•œë‹¤. <literal>Transaction</literal> ìš© íŒ©í† ë¦¬. ê°ì²´ 그래프를 네비게ì´íŠ¸ 하거나 ì‹ë³„ìžë¡œ ê°ì²´ë“¤ì„ ë£©ì—…í• ë•Œ 사용ë˜ëŠ” ì˜ì† ê°ì²´ë“¤ì— 대한 필수ì ì¸(첫 번째 ë ˆë²¨ì˜) ìºì‹œë¥¼ 보관한다."
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr "ì˜ì† ê°ì²´ë“¤ê³¼ ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr "persistent ìƒíƒœì™€ 비지니스 ê¸°ëŠ¥ì„ í¬í•¨í•˜ëŠ” ìˆ˜ëª…ì´ ì§§ê³ , ë‹¨ì¼ ì“°ë ˆë“œì¸ ê°ì²´ë“¤. ì´ê²ƒë“¤ì€ 통ìƒì˜ JavaBeans/POJOë“¤ì¼ ìˆ˜ ìžˆê³ , ì˜¤ì§ ê·¸ê²ƒë“¤ì— ëŒ€í•œ ì˜¤ì§ íŠ¹ë³„í•œ ê²ƒì€ ê·¸ê²ƒë“¤ì´ í˜„ìž¬ (ì •í™•í•˜ê²Œ í•œ ê°œì˜) <literal>Session</literal>ê³¼ ì—°ê´€ë˜ì–´ 있다는 ì ì´ë‹¤. <literal>Session</literal>ì´ ë‹«ížˆìžë§ˆìž, ê·¸ê²ƒë“¤ì€ ë¶„ë¦¬ë (detached ìƒíƒœê°€ ë ) 것ì´ê³ 어플리케ì´ì…˜ ë ˆì´ì–´ì—ì„œ 사용하는 ê²ƒì´ ìžìœ 로와진다(예를 들면. ì§ì ‘ì 으로 프리ì í…Œì´ì…˜ 계층으로 ë°ì´í„° ì „ì†¡ ê°ì²´ë“¤ë¡œì„œ ê·¸ë¦¬ê³ ì§ì ‘ì 으로 프리ì í…Œì´ì…˜ 계층으로부터 ë°ì´í„° ì „ì†¡ ê°ì²´ë“¤ë¡œì„œ)."
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr "ì „ì´(Transient, í•„ìž ì£¼-ê³¼ë„) ê°ì²´ë“¤ê³¼ ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:119
+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>ì— ì˜í•´ 초기화 ë˜ì—ˆì„ ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr "Transaction (<literal>org.hibernate.Transaction</literal>)"
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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>ì„ ì‚¬ìš©í•˜ëŠ” 트랜ìžì…˜ 경계 ì„¤ì •ì€ ê²°ì½” ì˜µì…˜ì´ ì•„ë‹ˆë‹¤!"
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr "(옵션) JDBC ì»¤ë„¥ì…˜ë“¤ì— ëŒ€í•œ íŒ©í† ë¦¬(ê·¸ë¦¬ê³ ê·¸ê²ƒë“¤ì˜ pool). 기본 <literal>Datasource</literal> ë˜ëŠ” <literal>DriverManager</literal>로부터 어플리케ì´ì…˜ì„ 추ìƒí™” 시킨다. 어플리케ì´ì…˜ì— 노출ë˜ì§€ëŠ” 않지만 개발ìžì— ì˜í•´ 확장/구현 ëœë‹¤."
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr "(옵션) <literal>Transaction</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 íŒ©í† ë¦¬. 어플리케ì´ì…˜ì— 노출ë˜ì§€ëŠ” 않지만 개발ìžì— ì˜í•´ 확장/구현 ëœë‹¤."
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr "Extension Interfaces"
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "Hibernate는 ë‹¹ì‹ ì˜ ì˜ì† ê³„ì¸µì˜ íŠ¹ì„±ì„ ë§žì¶¤í™” 시키기 위해 ë‹¹ì‹ ì´ êµ¬í˜„í• ìˆ˜ 있는 ì„ íƒì ì¸ í™•ìž¥ ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì„ ì œê³µí•œë‹¤. ìƒì„¸í•œ ê²ƒì€ API 문서를 ë³´ë¼."
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr "주어진 \"경량급\" 아키í…ì²˜ì˜ ê²½ìš°, 어플리케ì´ì…˜ì€ JTA ë˜ëŠ” JDBC와 ì§ì ‘ 대화하기 위해서 <literal>Transaction</literal>/<literal>TransactionFactory</literal> ê·¸ë¦¬ê³ /ë˜ëŠ” <literal>ConnectionProvider</literal> APIë“¤ì„ ë¬´ì‹œí•œë‹¤."
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr "ì¸ìŠ¤í„´ìŠ¤ ìƒíƒœë“¤"
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” ì„¸ê°œì˜ ìƒíƒœë“¤ 중 하나 ì¼ ìˆ˜ 있다. 그것들(ìƒíƒœë“¤)ì€ ì˜ì† 컨í…스트(<emphasis>persistence context</emphasis>)ì— ëŒ€í•´ ì •ì˜ëœë‹¤. Hibernate <literal>Session</literal> ê°ì²´ëŠ” ì˜ì† 컨í…스트ì´ë‹¤:"
+
+#: index.docbook:188
+msgid "transient"
+msgstr "transient"
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr "ì¸ìŠ¤í„´ìŠ¤ëŠ” ìž„ì˜ì˜ 컨í…스트와 ì—°ê´€ë˜ì–´ 있지 ì•Šê³ , ê²°ì½” ì—°ê´€ëœ ì ì´ ì—†ì—ˆë‹¤. ê·¸ê²ƒì€ ì˜ì† ì‹ë³„ìž(프ë¼ì´ë¨¸ë¦¬ 키 ê°’)ì„ ê°–ì§€ 않는다."
+
+#: index.docbook:198
+msgid "persistent"
+msgstr "persistent"
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr "ì¸ìŠ¤í„´ìŠ¤ëŠ” 현재 ì˜ì† 컨í…스트와 ì—°ê´€ë˜ì–´ 있다. ê·¸ê²ƒì€ ì˜ì† ì‹ë³„ìž(프ë¼ì´ë¨¸ë¦¬ 키 ê°’) ê·¸ë¦¬ê³ ì•„ë§ˆ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ìžˆëŠ” 대ì‘하는 í–‰ì„ ê°–ëŠ”ë‹¤. 특별한 ì˜ì† 컨í…ìŠ¤íŠ¸ì˜ ê²½ìš°, Hibernate는 ì˜ì† identityê°€ Java identity(ê°ì²´ì˜ 메모리 ë‚´ 위치)와 같다는 ì ì„ <emphasis>ë³´ì¦í•œë‹¤</emphasis>."
+
+#: index.docbook:212
+msgid "detached"
+msgstr "detached"
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr "ì¸ìŠ¤í„´ìŠ¤ëŠ” ì˜ì† 컨í…스트와 한번 ì—°ê´€ë˜ì—ˆì§€ë§Œ, ê·¸ 컨í…스트가 닫혔거나, ê·¸ ì¸ìŠ¤í„´ìŠ¤ê°€ ë˜ ë‹¤ë¥¸ 프로세스로 ì§ë ¬í™” ë˜ì—ˆë‹¤. ê·¸ê²ƒì€ ì˜ì† identity ê·¸ë¦¬ê³ , 아마 ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ëŒ€ì‘하는 í–‰ì„ ê°–ëŠ”ë‹¤. detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ 경우, Hibernate는 ì˜ì† identityê³¼ Java identity 사ì´ì˜ 관계를 ë³´ì¦í•˜ì§€ 않는다."
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr "JMX 통합"
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX는 ìžë°” ì»´í¬ë„ŒíŠ¸ 관리를 위한 J2EE 표준ì´ë‹¤. Hibernate는 JMX 표준 서비스를 통해 관리ë ìˆ˜ë„ ìžˆë‹¤. 우리는 ë°°í¬ë³¸ ë‚´ì— MBean 구현, <literal>org.hibernate.jmx.HibernateService</literal>를 ì œê³µí•œë‹¤."
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr "JBoss 어플리케ì´ì…˜ 서버 ìƒì— Hibernae를 JMX 서비스로서 배치하는 ë°©ë²•ì— ëŒ€í•œ ì˜ˆì œëŠ” JBoss ì‚¬ìš©ìž ê°€ì´ë“œë¥¼ 보길 바란다. JBoss 어플리케ì´ì…˜ 서버 ìƒì—ì„œ, ë§Œì¼ ë‹¹ì‹ ì´ JMX를 사용하여 ë°°ì¹˜í• ê²½ìš° ë‹¹ì‹ ì€ ë˜í•œ ë‹¤ìŒ ì´ì ë“¤ì„ ì–»ëŠ”ë‹¤:"
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>Session 관리:</emphasis> Hibernate <literal>Session</literal>ì˜ ìƒëª…주기가 JTA 트랜ìžì…˜ì˜ ì˜ì— ë‚´ì— ìžë™ì 으로 ë°”ì¸ë“œ ë 수 있다. ì´ê²ƒì€ ë‹¹ì‹ ì´ ë”ì´ìƒ <literal>Session</literal>ì„ ìˆ˜ìž‘ì—…ìœ¼ë¡œ ì—´ê³ ë‹«ì§€ ì•Šì•„ë„ ë¨ì„ ì˜ë¯¸í•˜ê³ , ì´ê²ƒì€ JBoss EJB ì¸í„°ì…‰í„°ì˜ 업무가 ëœë‹¤. ë‹¹ì‹ ì€ ë˜í•œ ë” ì´ìƒ ë‹¹ì‹ ì˜ ì½”ë“œ ì–´ëŠ ê³³ì—ì„œë“ íŠ¸ëžœìžì…˜ ê²½ê³„ì„¤ì •ì— ëŒ€í•´ ê±±ì •í•˜ì§€ ì•Šì•„ë„ ëœë‹¤(ë‹¹ì‹ ì´ ë¬¼ë¡ ì´ì‹ì„± 있는 ì˜ì† ê³„ì¸µì„ ìž‘ì„±í•˜ê³ ìž ì›í•˜ì§€ 않는한, ì´ë¥¼ 위해 옵션 Hibernate <literal>Transaction</literal> API를 사용하ë¼). ë‹¹ì‹ ì€ <literal>Session</literal>ì— ì ‘ê·¼í•˜ê¸° 위해 <literal>HibernateContext</literal>를 호출한다."
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>HAR 배치:</emphasis> 대개 ë‹¹ì‹ ì€ JBoss 서비스 배치 디스í¬ë¦½í„°ë¥¼ 사용하여 Hibernate JMX 서비스를 (EAR ê³¼/ë˜ëŠ” SAR 파ì¼ë¡œ) ë°°ì¹˜í•˜ê³ , ê·¸ê²ƒì€ Hibernate <literal>SessionFactory</literal>ì˜ í†µìƒì ì¸ êµ¬ì„± 옵션들 모ë‘를 지ì›í•œë‹¤. 하지만 ë‹¹ì‹ ì€ ì—¬ì „ížˆ ëª¨ë“ ë‹¹ì‹ ì˜ ë§¤í•‘ 파ì¼ë“¤ì„ 배치 디스í¬ë¦½í„° ì†ì— 명명해야 한다. ë§Œì¼ ë‹¹ì‹ ì´ ì˜µì…˜ HAR 배치를 ì‚¬ìš©í•˜ê³ ìž ê²°ì •í•˜ëŠ” 경우, JBoss는 ë‹¹ì‹ ì˜ HAR íŒŒì¼ ë‚´ì— ìžˆëŠ” ëª¨ë“ ë§¤í•‘ 파ì¼ë“¤ì„ ìžë™ì 으로 검출해낼 것ì´ë‹¤."
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr "ì´ë“¤ ì˜µì…˜ë“¤ì— ëŒ€í•œ 추가 ì •ë³´ëŠ” JBoss 어플리케ì´ì…˜ 서버 ì‚¬ìš©ìž ê°€ì´ë“œë¥¼ 참조하ë¼."
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr "JMX 서비스로서 ì´ìš© 가능한 ë˜ë‹¤ë¥¸ íŠ¹ì§•ì€ ëŸ°íƒ€ìž„ Hibernate 통계ì´ë‹¤. <xref linkend=\"configuration-optional-statistics\"/>를 ë³´ë¼."
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr "JCA 지ì›"
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr "Hibernate는 JCA 커넥터로서 구성ë ìˆ˜ë„ ìžˆë‹¤. ìƒì„¸í•œ ê²ƒì€ ì›¹ 사ì´íŠ¸ë¥¼ 보길 바란다. Hibernate JCA 지ì›ì€ ì—¬ì „ížˆ 실험ì 으로 ê²€í† ì¤‘ì— ìžˆìŒì„ 노트하길 바란다."
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr "컨í…스트 ìƒì˜ 세션들"
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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를 사용하는 ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì€ ì–´ë–¤ ì–‘ì‹ì˜ \"컨í…스트ìƒì˜(contextual)\" ì„¸ì…˜ë“¤ì„ í•„ìš”ë¡œ 한다. 여기서 주어진 ì„¸ì…˜ì€ ì£¼ì–´ì§„ 컨í…ìŠ¤íŠ¸ì˜ ì˜ì—ì— ê±¸ì³ í™œë™ì„ 한다. 하지만 어플리케ì´ì…˜ë“¤ì„ 가로질러 컨í…스트를 구성하는 ê²ƒì— ëŒ€í•œ ì •ì˜ëŠ” ì¼ë°˜ì 으로 다르다; ê·¸ë¦¬ê³ ë‹¤ë¥¸ 컨í…ìŠ¤íŠ¸ë“¤ì€ í˜„ìž¬ë¼ê³ 하는 ê°œë…ì— ëŒ€í•´ 다른 ì˜ì—ë“¤ì„ ì •ì˜í•œë‹¤. ë²„ì „ 3.0 ì „ì˜ Hibernate를 사용하는 어플리케ì´ì…˜ë“¤ì€ ìžê°€ìƒì‚°ëœ <literal>ThreadLocal</literal>-ê¸°ë°˜ì˜ ì»¨í…스ìƒì˜ 세션들, <literal>HibernateUtil</literal>ê³¼ ê°™ì€ helper í´ëž˜ìŠ¤ë“¤ì„ 활용했거나 프ë½ì‹œ/ì¸í„°ì…‰ì…˜ ê¸°ë°˜ì˜ ì»¨í…스트ìƒì˜ ì„¸ì…˜ë“¤ì„ ì œê³µí•´ì£¼ì—ˆë˜ (Spring ë˜ëŠ” Pico와 ê°™ì€ )ì œ 3ì˜ í”„ë ˆìž„ì›ë“¤ì„ 활용하는 ê²½í–¥ì´ ìžˆì—ˆë‹¤."
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr "ë²„ì „ 3.0.1ì—서부터 시작하여, Hibernate는 <literal>SessionFactory.getCurrentSession()</literal> 메소드를 추가했다. ì´ˆê¸°ì— ì´ê²ƒì€ <literal>JTA</literal> 트랜ìžì…˜ë“¤ì„ 사용하는 ê²ƒì„ ì „ì œí–ˆë‹¤. 여기서 <literal>JTA</literal> 트랜ìžì…˜ì€ 현재 ì„¸ì…˜ì˜ ì˜ì—ê³¼ 컨í…스트를 ì •ì˜í–ˆë‹¤. Hibernate íŒ€ì€ ì„±ìˆ™ëœ ë‹¤ìˆ˜ì˜ ìŠ¤íƒ ë“œì–¼ë¡ <literal>JTA TransactionManager</literal> êµ¬í˜„ë“¤ì´ ë°œí‘œë˜ë©´, (ì „ë¶€ëŠ” ì•„ë‹ˆê² ì§€ë§Œ) ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì´ ê·¸ê²ƒë“¤ì´ <literal>J2EE</literal> 컨테ì´ë„ˆ ë‚´ë¡œ 배치ë˜ë“ ê·¸ë ‡ì§€ ì•Šë“ ê°„ì— <literal>JTA</literal> 트랜ìžì…˜ 관리를 사용하게 ë 것ì´ë¼ê³ 주장한다. ê·¸ê²ƒì— ê¸°ì´ˆí•˜ì—¬, <literal>JTA</literal>ì— ê¸°ë°˜í•œ 컨í…스트ìƒì˜ ì„¸ì…˜ë“¤ì€ ì–¸ì ê°€ ë‹¹ì‹ ì´ ì‚¬ìš©ì„ í•„ìš”ë¡œ 하게 ë ì „ë¶€ë‹¤."
+
+#: index.docbook:307
+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>)ê°€ 현재 ì„¸ì…˜ë“¤ì„ ì •ì˜í•˜ëŠ” ì˜ì—ê³¼ 컨í…ìŠ¤íŠ¸ì˜ í”ŒëŸ¬ê·¸ ê°€ëŠ¥ì„±ì„ í—ˆìš©í•˜ê¸° 위해 추가ë˜ì—ˆë‹¤."
+
+#: index.docbook:314
+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> ì¸í„°íŽ˜ì´ìŠ¤ì— 관한 javadocs를 ë³´ë¼. ê·¸ê²ƒì€ í•˜ë‚˜ì˜ ë©”ì†Œë“œ, <literal>currentSession()</literal>를 ì •ì˜í•˜ë©°, ê·¸ êµ¬í˜„ì€ í˜„ìž¬ì˜ ì»¨í…스트 ìƒì˜ ì„¸ì…˜ì„ ì¶”ì í• ì±…ìž„ì´ ìžˆë‹¤. 비공ì‹ì 으로, Hibernate는 ì´ ì¸í„°íŽ˜ì´ìŠ¤ì— 대한 세 ê°œì˜ êµ¬í˜„ë“¤ì„ ë¶€ìˆ˜ì 으로 í¬í•¨í•˜ê³ 있다."
+
+#: index.docbook:324
+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-ì „ìš© ì ‘ê·¼ê³¼ ì •í™•í•˜ê²Œ ë™ì¼í•˜ë‹¤. ìƒì„¸í•œ ê²ƒì€ javadocs를 ë³´ë¼."
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - í˜„ìž¬ì˜ ì„¸ì…˜ë“¤ì€ ì‹¤í–‰ ì“°ë ˆë“œì— ì˜í•´ 추ì ëœë‹¤. ìƒì„¸í•œ ê²ƒì€ ë‹¤ì‹œ javadocs를 ë³´ë¼."
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr "처ìŒì˜ ë‘ êµ¬í˜„ë“¤ì€ <emphasis>session-per-request</emphasis>ë¡œ ì•Œë ¤ì§€ê³ ì‚¬ìš©ë˜ê³ 있는 \"í•˜ë‚˜ì˜ ì„¸ì…˜ - í•˜ë‚˜ì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜\" í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ì„ ì œê³µí•œë‹¤. í•˜ë‚˜ì˜ Hibernate ì„¸ì…˜ì˜ ì‹œìž‘ê³¼ ëì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì˜ ì¡´ì† ê¸°ê°„ì— ì˜í•´ ì •ì˜ëœë‹¤. ë§Œì¼ (예를 들면 순수 J2SEì—ì„œ ë˜ëŠ” JTA/UserTransaction/BMTì˜ ê²½ìš°ì—) ë‹¹ì‹ ì´ í”„ë¡œê·¸ëž¨ ìƒì˜ 트랜ìžì…˜ ê²½ê³„êµ¬ë¶„ì„ ì‚¬ìš©í• ê²½ìš°, ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì½”ë“œë¡œë¶€í„° 기본 트랜ìžì…˜ ì‹œìŠ¤í…œì„ ì€íì‹œí‚¤ëŠ”ë° Hibernate <literal>Transaction</literal> API를 사용하는 ê²ƒì´ ê¶Œìž¥ëœë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ CMT를 지ì›í•˜ëŠ” í•˜ë‚˜ì˜ EJB 컨테ì´ë„ˆì—ì„œ ì‹¤í–‰í• ê²½ìš°, 트랜ìžì…˜ ê²½ê³„ë“¤ì´ ì„ ì–¸ì 으로 ì •ì˜ë˜ê³ ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì½”ë“œ ë‚´ì— ì–´ë–¤ 트랜ìžì…˜ë„ 세션 경계구분 오í¼ë ˆì´ì…˜ë“¤ì„ 필요로 하지 않는다. 추가 ì •ë³´ì™€ 코드 ì˜ˆì œë“¤ì€ <xref linken!
d=\"transactions\"/>를 참조하ë¼."
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+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\"ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,952 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr "연관 매핑들"
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr "<title>개요</title>"
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr "ì—°ê´€ ë§¤í•‘ë“¤ì€ ì˜¬ë°”ë¥¸ ê²ƒì„ ì–»ê¸°ê°€ 종종 가장 ì–´ë ¤ìš´ 것ì´ë‹¤. ì´ ì ˆì—ì„œ 우리는 단방향 매핑들ì—ì„œ ì‹œìž‘í•˜ê³ , 그런 ë‹¤ìŒ ì–‘ë°©í–¥ ê²½ìš°ë“¤ì„ ê²€í† í•¨ìœ¼ë¡œì¨, 하나씩 표준ì ì¸ ê²½ìš°ë“¤ì„ ìƒì„¸ížˆ ë…¼ì˜í• 것ì´ë‹¤. 우리는 ëª¨ë“ ì˜ˆì œë“¤ì—ì„œ <literal>Person</literal>ê³¼ <literal>Address</literal>를 ì‚¬ìš©í• ê²ƒì´ë‹¤."
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr "우리는 ì—°ê´€ë“¤ì„ ì¤‘ìž¬í•˜ëŠ” join í…Œì´ë¸”ë¡œ 매핑시킬 것ì¸ì§€ ì—¬ë¶€ì— ë”°ë¼, ê·¸ë¦¬ê³ multiplicity(다중성)ì— ë”°ë¼ ì—°ê´€ë“¤ì„ ë¶„ë¥˜í• ê²ƒì´ë‹¤."
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr "null 허용 가능한 foreign í‚¤ë“¤ì€ ì „í†µì ì¸ ë°ì´í„° 모ë¸ë§ì—ì„œ ì¢‹ì€ ì‹¤ë¡€ë¡œ 간주ë˜ì§€ ì•Šì•„ì„œ, ëª¨ë“ ìš°ë¦¬ì˜ ì˜ˆì œë“¤ì€ not null foreign í‚¤ë“¤ì„ ì‚¬ìš©í•œë‹¤. ì´ê²ƒì€ Hibernateì—ì„œ 필수가 ì•„ë‹ˆê³ , ë‹¹ì‹ ì´ null 허용 가능 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ì„ ë“œë¡ì‹œí‚¬ 경우 ë§¤í•‘ë“¤ì€ ëª¨ë‘ ë™ìž‘í• ê²ƒì´ë‹¤."
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr "단방향 연관들"
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr "many to one"
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr "<emphasis>단방향 many-to-one ì—°ê´€</emphasis>ì€ ê°€ìž¥ 공통ì ì¸ ì¢…ë¥˜ì˜ ë‹¨ë°©í–¥ ì—°ê´€ì´ë‹¤."
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr "one to one"
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr "<emphasis>foreign í‚¤ì— ëŒ€í•œ 단방향 one-to-one ì—°ê´€ì€ ëŒ€ê°œ 아주 ë™ì¼í•˜ë‹¤.</emphasis> ìœ ì¼í•œ ì°¨ì´ì ì€ ì»¬ëŸ¼ ìœ ì¼(unique) ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì´ë‹¤."
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr "<emphasis>í•˜ë‚˜ì˜ í”„ë¼ì´ë¨¸ë¦¬ í‚¤ì— ëŒ€í•œ 단방향 one-to-one ì—°ê´€</emphasis>ì€ ëŒ€ê°œ 특별한 id ìƒì„±ê¸°ë¥¼ 사용한다. (ì´ ì˜ˆì œì—ì„œ ì—°ê´€ì˜ ë°©í–¥ì´ ì—ì „ë˜ì—ˆìŒì„ 주목하ë¼.)"
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr "one to many"
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr "<emphasis>í•˜ë‚˜ì˜ foreign í‚¤ì— ëŒ€í•œ 단방향 one-to-many ì—°ê´€</emphasis>ì€ ë§¤ìš° 색다른 경우ì´ê³ , ì‹¤ì œë¡œ 권장ë˜ì§€ 않는다."
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr "우리는 ì´ëŸ° ì¢…ë¥˜ì˜ ì—°ê´€ì— ëŒ€í•´ í•˜ë‚˜ì˜ join í…Œì´ë¸”ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì´ ë” ì¢‹ë‹¤ê³ ìƒê°í•œë‹¤."
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr "join í…Œì´ë¸”ë“¤ì— ëŒ€í•œ 단방향 연관들"
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr "<emphasis>í•˜ë‚˜ì˜ join í…Œì´ë¸”ì— ëŒ€í•œ 단방향 one-to-many ì—°ê´€</emphasis>ì´ ë³´ë‹¤ ë” ì„ í˜¸ëœë‹¤. <literal>unique=\"true\"</literal>를 ì§€ì •í•¨ìœ¼ë¡œì¨ ìš°ë¦¬ëŠ” many-to-manyì—ì„œ one-to-manyë¡œ 아중성(multiplicity)를 변경시켰ìŒì„ 주목하ë¼."
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr "<emphasis>í•˜ë‚˜ì˜ join í…Œì´ë¸”ì— ëŒ€í•œ 단방향 many-to-one ì—°ê´€</emphasis>ì€ ê·¸ ì—°ê´€ì´ ì„ íƒì ì¼ ë•Œ 매우 공통ì ì´ë‹¤."
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "<emphasis>í•˜ë‚˜ì˜ join í…Œì´ë¸”ì— ëŒ€í•œ 단방향 one-to-one ì—°ê´€</emphasis>ì€ ê·¹ížˆ 통ìƒì ì´ì§€ 않지만 가능하다."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr "many to many"
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr "마지막으로, 우리는 <emphasis>단방향 many-to-many ì—°ê´€</emphasis>ì„ ê°–ëŠ”ë‹¤."
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr "양방향 연관들"
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr "one to many / many to one"
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr "<emphasis>ì–‘ë°©í–¥ many-to-one ì—°ê´€</emphasis>ì€ ê°€ìž¥ ê³µí†µëœ ì¢…ë¥˜ì˜ ì—°ê´€ì´ë‹¤.(ì´ê²ƒì€ 표준 부모/ìžì‹ 관계ì´ë‹¤. )"
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>List</literal>(ë˜ëŠ” 다른 ì¸ë±ì‹± ëœ ì½œë ‰ì…˜)ì„ ì‚¬ìš©í• ê²½ìš° ë‹¹ì‹ ì€ foreign keyì˜ <literal>key</literal> ì»¬ëŸ¼ì„ <literal>not null</literal>ë¡œ ì„¤ì •í•˜ê³ , Hibernateë¡œ 하여금 ê°ê°ì˜ ìš”ì†Œì˜ ì¸ë±ìŠ¤ë¥¼ ìœ ì§€ê´€ë¦¬í•˜ê¸° 위해 (<literal>update=\"false\"</literal>와 <literal>insert=\"false\"</literal>를 ì„¤ì •í•¨ìœ¼ë¡œì¨ ë‹¤ë¥¸ ì¸¡ì„ ê°€ìƒì 으로 inverseë¡œ 만들어) ê·¸ ì½œë ‰ì…˜ë“¤ 측으로부터 ì—°ê´€ì„ ê´€ë¦¬í•˜ë„ë¡ í• í•„ìš”ê°€ 있다:"
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr "ë§Œì¼ ê¸°ë³¸ 외래 키 ì»¬ëŸ¼ì´ <literal>NOT NULL</literal>ì¼ ê²½ìš° ì½œë ‰ì…˜ ë§¤í•‘ì˜ <literal><key></literal> 요소 ìƒì— <literal>not-null=\"true\"</literal>를 ì •ì˜í•˜ëŠ” ê²ƒì´ ì¤‘ìš”í•˜ë‹¤. ë‚´í¬ëœ <literal><column></literal> 요소 ìƒì— <literal>not-null=\"true\"</literal>를 ì„ ì–¸í•˜ì§€ ë§ê³ , <literal><key></literal> 요소 ìƒì— ì„ ì–¸í•˜ë¼."
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr "<emphasis>foreignì— ëŒ€í•œ ì–‘ë°©í–¥ one-to-one ì—°ê´€</emphasis>ì€ ê½¤ 공통ì ì´ë‹¤."
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr "<emphasis>í•˜ë‚˜ì˜ í”„ë¼ì´ë¨¸ë¦¬ í‚¤ì— ëŒ€í•œ ì–‘ë°©í–¥ one-to-one ì—°ê´€</emphasis>ì€ íŠ¹ë³„í•œ id ìƒì„±ê¸°ë¥¼ 사용한다."
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr "join í…Œì´ë¸”ë“¤ì— ëŒ€í•œ ì–‘ë°©í–¥ 연관들"
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr "<emphasis>í•˜ë‚˜ì˜ join í…Œì´ë¸”ì— ëŒ€í•œ ì–‘ë°©í–¥ one-to-many ì—°ê´€</emphasis>. <literal>inverse=\"true\"</literal>는 ì—°ê´€ì˜ ì–´ëŠ ìª½ ëì´ë“ ì½œë ‰ì…˜ 측으로 ë˜ëŠ” join 측으로 ê°ˆ 수 있다."
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr "<emphasis>í•˜ë‚˜ì˜ join í…Œì´ë¸”ì— ëŒ€í•œ ì–‘ë°©í–¥ one-to-one ì—°ê´€</emphasis>ì€ ê·¹ížˆ 통ìƒì ì´ì§€ 않지만, 가능하다."
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr "마지막으로, 우리는 í•˜ë‚˜ì˜ <emphasis>ì–‘ë°©í–¥ many-to-many ì—°ê´€</emphasis>ì„ ê°–ëŠ”ë‹¤."
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr "보다 복잡한 연관 매핑들"
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr "보다 복잡한 ì—°ê´€ ì¡°ì¸ë“¤ì€ <emphasis>극기</emphasis> 드물다. Hibernate는 매핑 문서들 ë‚´ì— ì‚½ìž…ëœ SQL ì¡°ê°ë“¤ì„ 사용하여 보다 복잡한 ìƒí™©ì„ 처리하는 ê²ƒì„ ê°€ëŠ¥í•˜ë„ë¡ í•´ì¤€ë‹¤. 예를 들어, ë§Œì¼ ê³„ì¢Œ ë‚´ì— ì •ë³´ ë°ì´í„°ë¥¼ 가진 í•˜ë‚˜ì´ í…Œì´ë¸”ì´ <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> ê·¸ë¦¬ê³ <literal>effectiveStartDate</literal> ì»¬ëŸ¼ë“¤ì„ ì •ì˜í• 경우, 다ìŒê³¼ ê°™ì´ ë§¤í•‘ëœë‹¤:"
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr "그때 우리는 다ìŒì„ 사용하여 í•˜ë‚˜ì˜ ì—°ê´€ì„ <emphasis>현재</emphasis> ì¸ìŠ¤í„´ìŠ¤ (null <literal>effectiveEndDate</literal>ì„ ê°€ì§„ ì¸ìŠ¤í„´ìŠ¤)ë¡œ 매핑시킬 수 있다:"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr "보다 복잡한 ì˜ˆì œì—ì„œ, <literal>Employee</literal>와 <literal>Organization</literal> 사ì´ì˜ ì—°ê´€ì´ ì „ì²´ ê³ ìš© ë‚´ì— ë°ì´í„°ë¥¼ 가진 <literal>Employment</literal> í…Œì´ë¸” ë‚´ì— ìœ ì§€ëœë‹¤ê³ ê°€ì •í•˜ìž. 그때 종업ì›ì˜ <emphasis>가장 최근ì˜</emphasis> ê³ ìš©ì£¼ì— ëŒ€í•œ í•˜ë‚˜ì˜ ì—°ê´€(가장 ìµœê·¼ì˜ <literal>startDate</literal>를 ê°–ê³ ìžˆëŠ” 것)ì´ ë‹¤ìŒ ë°©ë²•ìœ¼ë¡œ 매핑ë 수 있다:"
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr "ë‹¹ì‹ ì€ ì´ ê¸°ëŠ¥ìœ¼ë¡œ 아주 ìƒì‚°ì„±ì„ ì–»ì„ ìˆ˜ 있지만, ê·¸ê²ƒì€ ëŒ€ê°œ HQL ë˜ëŠ” criteria 질ì˜ë¥¼ 사용하여 ì´ë“¤ ì¢…ë¥˜ì˜ ê²½ìš°ë“¤ì„ ì²˜ë¦¬í•˜ëŠ” ê²ƒì´ ë³´ë‹¤ 실용ì ì´ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,3067 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr "기본 O/R 매핑"
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr "매핑 ì„ ì–¸"
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr "ê°ì²´/관계형 ë§¤í•‘ë“¤ì€ ëŒ€ê°œ XML 문서 ë‚´ì— ì •ì˜ëœë‹¤. 매핑 문서는 ê°€ë…ì„±ì´ ìžˆê³ ìˆ˜ìž‘ì—… íŽ¸ì§‘ì´ ê°€ëŠ¥í•˜ë„ë¡ ì„¤ê³„ë˜ì–´ 있다. 매핑 언어는 ë§¤í•‘ë“¤ì´ í…Œì´ë¸” ì„ ì–¸ë“¤ì´ ì•„ë‹Œ, ì˜ì† í´ëž˜ìŠ¤ ì„ ì–¸ë“¤ë¡œ ìƒì„±ëœë‹¤ëŠ” ì˜ë¯¸ì—ì„œ ìžë°” 중심ì ì´ë‹¤."
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr "심지어 ë§Žì€ Hibernate 사용ìžë“¤ì´ 수작업으로 XMLì„ ìž‘ì„±í•˜ê³ ìž ì„ íƒí• 지ë¼ë„, XDoclet, Middlegen, ê·¸ë¦¬ê³ AndroMDA를 í¬í•¨í•˜ëŠ”, 매핑 문서를 ìƒì„±ì‹œí‚¤ëŠ” ë§Žì€ ë„êµ¬ë“¤ì´ ì¡´ìž¬í•œë‹¤ëŠ” ì ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr "ì˜ˆì œ 매핑으로 시작하ìž:"
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" \n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\" \n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\" \n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\" \n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr "우리는 ì´ì œ 매핑 ë¬¸ì„œì˜ ë‚´ìš©ì„ ë…¼ì˜í• 것ì´ë‹¤. 우리는 Hibernateì— ì˜í•´ 실행 ì‹œì— ì‚¬ìš©ë˜ëŠ” 문서 요소들과 ì†ì„±ë“¤ ë§Œì„ ì„¤ëª…í• ê²ƒì´ë‹¤. 매핑 문서는 ë˜í•œ 스키마 내보내기 ë„êµ¬ì— ì˜í•´ 내보내진 ë°ì´í„°ë² ì´ìŠ¤ ìŠ¤í‚¤ë§ˆì— ì˜í–¥ì„ 주는 ì–´ë–¤ 특별한 옵션 ì†ì„±ë“¤ê³¼ ìš”ì†Œë“¤ì„ í¬í•¨í•œë‹¤. (예를 들어 <literal>not-null</literal> ì†ì„±.)"
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr "Doctype"
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr "ëª¨ë“ XML ë§¤í•‘ë“¤ì€ doctypeì´ ë³´ì´ê²Œ ì„ ì–¸í•´ì•¼ 한다. ì‹¤ì œ DTD는 ìœ„ì˜ URLì—ì„œ, <literal>hibernate-x.x.x/src/org/hibernate</literal> ë””ë ‰í† ë¦¬ ë‚´ì—ì„œ ë˜ëŠ” <literal>hibernate3.jar</literal> ë‚´ì—ì„œ ì°¾ì„ ìˆ˜ 있다. Hibernate는 í•ìƒ 첫 번째로 ê·¸ê²ƒì˜ classpath ì†ì—ì„œ DTD를 찾게 ë 것ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì¸í„°ë„· ì—°ê²°ì„ ì‚¬ìš©í•˜ëŠ” DTDì— ëŒ€í•œ ë£©ì—…ë“¤ì„ ê²ªê²Œ ë 경우, ë‹¹ì‹ ì˜ classpathì˜ ì»¨í…ì¸ ì— ëŒ€í•´ ë‹¹ì‹ ì˜ DTD ì„ ì–¸ì„ ì²´í¬í•˜ë¼."
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr "EntityResolver"
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr "ì•žì„œ 언급했듯ì´, Hibernate는 ë¨¼ì € ê·¸ê²ƒì˜ classpathì—ì„œ DTDë“¤ì„ í•´ì„í•˜ë ¤ê³ ì‹œë„í• ê²ƒì´ë‹¤. Hibernateê°€ ì´ê²ƒì„ 행하는 ë°©ë²•ì€ ê·¸ê²ƒì´ xml 파ì¼ë“¤ì„ ì½ì–´ë“¤ì´ëŠ”ë° ì‚¬ìš©í•˜ëŠ” SAXReaderì— ë§žì¶¤í˜• <literal>org.xml.sax.EntityResolver</literal> êµ¬í˜„ì„ ë“±ë¡í•˜ëŠ” 것ì´ë‹¤. ì´ ë§žì¶¤í˜• <literal>EntityResolver</literal>는 ë‘ ê°œì˜ ë‹¤ë¥¸ systemId namespaceë“¤ì„ ì¸ì§€í•´ë‚¸ë‹¤."
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr "<literal>hibernate namespace</literal>는 resolverê°€ <literal>http://hibernate.sourceforge.net/</literal>ë¡œ 시작하는 í•˜ë‚˜ì˜ systemId와 ë§Œë‚ ë•Œë§ˆë‹¤ ì¸ì§€ëœë‹¤; resolver는 Hibernate í´ëž˜ìŠ¤ë“¤ì„ ë¡œë“œì‹œì¼°ë˜ í´ëž˜ìŠ¤ë¡œë”를 통해 ì´ë“¤ ì—”í‹°í‹°ë“¤ì„ í•´ì„í•˜ë ¤ê³ ì‹œë„한다."
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "<literal>user namespace</literal>는 resolverê°€ <literal>classpath://</literal> URL í”„ë¡œí† ì½œì„ ì‚¬ìš©í•˜ëŠ” systemId를 ë§Œë‚ ë•Œë§ˆë‹¤ ì¸ì§€ëœë‹¤; resolver는 (1)현재 ì“°ë ˆë“œ 컨í…스트 í´ëž˜ìŠ¤ë¡œë”와 (2)Hibernate í´ëž˜ìŠ¤ë“¤ì„ ë¡œë“œì‹œì¼°ë˜ í´ëž˜ìŠ¤ë¡œë”를 통해 ì´ë“¤ ì—”í‹°í‹°ë“¤ì„ í•´ì„í•˜ë ¤ê³ ì‹œë„í• ê²ƒì´ë‹¤."
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr "user namespacingì„ í™œìš©í•˜ëŠ” ì˜ˆì œ:"
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr "여기서 <literal>types.xml</literal>ì€ <literal>your.domain</literal> 패키지 ë‚´ì— ìžˆëŠ” 리소스ì´ê³ 맞춤형 <xref linkend=\"mapping-types-custom\"/>typedef를 í¬í•¨í•œë‹¤."
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr "hibernate-mapping"
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr "ì´ ìš”ì†ŒëŠ” 몇 ê°œì˜ ì„ íƒì ì¸ ì†ì„±ë“¤ì„ 갖는다. <literal>schema</literal> ì†ì„±ê³¼ <literal>catalog</literal> ì†ì„±ì€ ì´ ë§¤í•‘ ë‚´ì—ì„œ ì°¸ì¡°ëœ í…Œì´ë¸”ë“¤ì´ ëª…ëª…ëœ schema 와/ë˜ëŠ” catalogì— ì†í•œë‹¤ëŠ” ì ì„ ì§€ì •í•œë‹¤. ë§Œì¼ ì§€ì •ë 경우, í…Œì´ë¸” ì´ë¦„ë“¤ì€ ì£¼ì–´ì§„ schema ì´ë¦„ê³¼ catalog ì´ë¦„ì— ì˜í•´ í•œì •(수ì‹)ë 것ì´ë‹¤. 누ë½ë 경우, í…Œì´ë¸” ì´ë¦„ë“¤ì€ í•œì •ë˜ì§€((수ì‹ì–´ê°€ 붙지) ì•Šì„ ê²ƒì´ë‹¤. <literal>default-cascade</literal> ì†ì„±ì€ <literal>cascade</literal> ì†ì„±ì„ ì§€ì •í•˜ì§€ ì•Šì€ í”„ë¡œí¼í‹°ë“¤ê³¼ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ ì „ì œë <literal>cascade</literal> 스타ì¼ì´ 무엇ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤. <literal>auto-import</literal> ì†ì„±ì€ ë””í´íŠ¸ë¡œ 우리가 ì§ˆì˜ ì–¸ì–´ ì†ì—ì„œ 수ì‹ì–´ê°€ 붙지 ì•Šì€(unqualified) í´ëž˜ìŠ¤ ì´ë¦„ë“¤ì„ ì‚¬ìš©í•˜ê²Œ í• ê²ƒì´ë‹¤."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr "<literal>schema</literal> (옵션): ë°ì´í„°ë² ì´ìŠ¤ ìŠ¤í‚¤ë§ˆì˜ ì´ë¦„."
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr "<literal>catalog</literal> (옵션): ë°ì´í„°ë² ì´ìŠ¤ 카다ë¡ì˜ ì´ë¦„."
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr "<literal>default-cascade</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>none</literal>): ë””í´íŠ¸ cascade 스타ì¼."
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "<literal>default-access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤ì— ì•¡ì„¸ìŠ¤í•˜ëŠ”ë° ì‚¬ìš©í•˜ê²Œ ë ë°©ë„. <literal>PropertyAccessor</literal>ì— ëŒ€í•œ 맞춤형 êµ¬í˜„ì¼ ìˆ˜ 있다."
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr "<literal>default-lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): class ë° collection ë§¤í•‘ë“¤ì˜ ì§€ì •ë˜ì§€ ì•Šì€ <literal>lazy</literal> ì†ì„±ë“¤ì— 대한 ë””í´íŠ¸ ê°’."
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr "<literal>auto-import</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): 우리가 ì§ˆì˜ ì–¸ì–´ ë‚´ì— (ì´ ë§¤í•‘ì—ì„œ í´ëž˜ìŠ¤ë“¤ì— 대해) 수ì‹ì–´ê°€ 붙지 ì•Šì€ í´ëž˜ìŠ¤ ì´ë¦„ë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있는지를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr "<literal>package</literal> (옵션): 매핑 문서 ë‚´ì—ì„œ 수ì‹ì–´ê°€ 붙지 ì•Šì€ í´ëž˜ìŠ¤ ì´ë¦„ë“¤ì— ëŒ€í•´ ê°€ì •í• íŒ¨í‚¤ì§€ ì ‘ë‘어를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë™ì¼í•œ (수ì‹ì–´ê°€ 붙지 ì•Šì€) ì´ë¦„ì„ ê°€ì§„ ë‘ ê°œì˜ ì˜ì† í´ëž˜ìŠ¤ë“¤ì„ ê°–ê³ ìžˆë‹¤ë©´, ë‹¹ì‹ ì€ <literal>auto-import=\"false\"</literal>를 ì„¤ì •í•´ì•¼ 한다. ë§Œì¼ ë‹¹ì‹ ì´ ë‘ ê°œì˜ í´ëž˜ìŠ¤ë“¤ì— ë™ì¼í•œ \"imported\" ì´ë¦„ì„ í• ë‹¹í•˜ë ¤ê³ ì‹œë„í• ê²½ìš°ì— Hibernate는 예외ìƒí™©ì„ ë˜ì§ˆ 것ì´ë‹¤."
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "ìœ„ì— ë³´ì—¬ì§„ 것처럼 <literal>hibernate-mapping</literal> 요소는 몇몇 ì˜ì† <literal><class></literal> ë§¤í•‘ë“¤ì„ ë‚´ë¶€ì— í¬í•¨í•˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤ëŠ” ì ì„ ë…¸íŠ¸í•˜ë¼. 하지만 í•œ ê°œì˜ ë§¤í•‘ íŒŒì¼ ì†ì— í•œ ê°œì˜ ì˜ì† í´ëž˜ìŠ¤(ë˜ëŠ” í•œ ê°œì˜ í´ëž˜ìŠ¤ 계층구조) ë§Œì„ ë§¤í•‘í•˜ê³ ì˜ì† 서브 í´ëž˜ìŠ¤ ë’¤ì— ê·¸ê²ƒì„ ëª…ëª…í•˜ëŠ” ê²ƒì´ ì¢‹ì€ ì—°ìŠµì´ë‹¤ (ê·¸ë¦¬ê³ ëª‡ëª‡ ë„êµ¬ë“¤ì— ì˜í•´ 기대ëœë‹¤). 예를 들면 <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal> ë˜ëŠ” ìƒì†ì„ ì‚¬ìš©í• ê²½ìš°ì—는 <literal>Animal.hbm.xml</literal>."
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr "<title>class</title>"
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr "ë‹¹ì‹ ì€ <literal>class</literal> 요소를 사용하여 ì˜ì† í´ëž˜ìŠ¤ë¥¼ ì„ ì–¸í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>name</literal> (옵션): ì˜ì† í´ëž˜ìŠ¤(ë˜ëŠ” ì¸í„°íŽ˜ì´ìŠ¤)ì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ Java í´ëž˜ìŠ¤ ì´ë¦„. ë§Œì¼ ì´ ì†ì„±ì´ 누ë½ë 경우, ë§¤í•‘ì´ non-POJO 엔티티ë¼ê³ ê°€ì •ëœë‹¤."
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr "<literal>table</literal> (옵션 - ë””í´íŠ¸ëŠ” 수ì‹ì–´ê°€ 붙지 ì•Šì€ í´ëž˜ìŠ¤ëª…): ê·¸ê²ƒì˜ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì˜ ì´ë¦„."
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>discriminator-value</literal> (옵션 - ë””í´íŠ¸ëŠ” í´ëž˜ìŠ¤ ì´ë¦„): 다형성(polymorphic) íŠ¹ì§•ì— ì‚¬ìš©ë˜ëŠ”, 개별 서브 í´ëž˜ìŠ¤ë“¤ë¥¼ 구별짓는 ê°’. 허용가능한 값들ì€<literal>null</literal>ê³¼ <literal>not null</literal>ì„ í¬í•¨í•œë‹¤."
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr "<literal>mutable</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ 가변ì ì¸ì§€ë¥¼ (가변ì ì´ì§€ ì•Šì€ì§€ë¥¼) ì§€ì •í•œë‹¤."
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>schema</literal> (옵션): 루트 <literal><hibernate-mapping></literal> ìš”ì†Œì— ì˜í•´ ì§€ì •ëœ ìŠ¤í‚¤ë§ˆ ì´ë¦„ì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다."
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>catalog</literal> (옵션): 루트 <literal><hibernate-mapping></literal> ìš”ì†Œì— ì˜í•´ ì§€ì •ëœ ì¹´ë‹¤ë¡ ì´ë¦„ì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다."
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr "<literal>proxy</literal> (옵션): lazy initializing proxyë“¤ì— ì‚¬ìš©í• ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ ì§€ì •í•œë‹¤. ë‹¹ì‹ ì€ í´ëž˜ìŠ¤ ê·¸ ìžì²´ì˜ ì´ë¦„ì„ ì§€ì •í• ìˆ˜ ë„ ìžˆë‹¤."
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr "<literal>dynamic-update</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): <literal>UPDATE</literal> SQLì´ ì‹¤í–‰ ì‹œì— ìƒì„±ë˜ê³ 그들 ì»¬ëŸ¼ë“¤ì˜ ê°’ë“¤ì´ ë³€ê²½ëœ ê·¸ë“¤ 컬럼들 ë§Œì„ í¬í•¨í• 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>dynamic-insert</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ìƒì„±ë <literal>INSERT</literal>ì´ ì‹¤í–‰ ì‹œì— ìƒì„±ë˜ê³ 그들 ì»¬ëŸ¼ë“¤ì˜ ê°’ì´ nullì´ ì•„ë‹Œ 컬럼들 ë§Œì„ í¬í•¨í• 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>select-before-update</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ê°ì²´ê°€ ì‹¤ì œë¡œ 변경ë˜ëŠ” ê²ƒì´ í™•ì‹¤í•˜ì§€ 않는 í•œ, Hibernateê°€ SQL <literal>UPDATE</literal>를 <emphasis>ê²°ì½”</emphasis> 실행하지 ì•Šì„ ê²ƒìž„ì„ ì§€ì •í•œë‹¤. ì–´ë–¤ 경우들ì—ì„œ(ì‹¤ì œë¡œ transient ê°ì²´ê°€ <literal>update()</literal>를 사용하여 새로운 sessionì— ì—°ê´€ë˜ì—ˆì„ ë•Œì—만), ì´ê²ƒì€ í•˜ë‚˜ì˜ <literal>UPDATE</literal>ê°€ ì‹¤ì œë¡œ 필요한 경우ì¸ì§€ 여부를 ê²°ì •í•˜ê¸° 위해 Hibernate는 특별한 SQL <literal>SELECT</literal>를 ì‹¤í–‰í• ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr "<literal>polymorphism</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>implicit</literal>): implicit ì§ˆì˜ ë‹¤í˜•ì„±ì´ë‚˜ explicit ì§ˆì˜ ë‹¤í˜•ì„± 중 ì–´ëŠ ê²ƒì´ ì‚¬ìš©ë 것ì¸ì§€ë¥¼ ê²°ì •í•œë‹¤."
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr "<literal>where</literal> (옵션) ì´ í´ëž˜ìŠ¤ì˜ ê°ì²´ë“¤ì„ ê²€ìƒ‰í• ë•Œ 사용ë ìž„ì˜ì ì¸ SQL <literal>WHERE</literal> ì¡°ê±´ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>persister</literal> (옵션): 맞춤형 <literal>ClassPersister</literal>를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>batch-size</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>1</literal>) ì‹ë³„ìžì— ì˜í•´ ì´ í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 페치시키는 \"배치 사ì´ì¦ˆ\"를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>version</literal>): optimistic ìž ê¸ˆ ë°©ë„를 ê²°ì •í•œë‹¤."
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "<literal>lazy</literal> (옵션): <literal>lazy=\"false\"</literal>를 ì„¤ì •í•¨ìœ¼ë¡œì¨ Lazy fetchingì´ ì „ì²´ì 으로 사용불가능하게 ë 수 있다."
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr "<literal>entity-name</literal>(옵션, ë””í´íŠ¸ëŠ” í´ëž˜ìŠ¤ ì´ë¦„): Hibernate3는 í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ê°€ (ìž ì •ì 으로 다른 í…Œì´ë¸”들로) 여러번 매핑ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì£¼ê³ , Java ë ˆë²¨ì—ì„œ Map ë˜ëŠ” XMLì— ì˜í•´ 표현 ë˜ëŠ” 엔티티 ë§¤í•‘ë“¤ì„ í—ˆìš©í•œë‹¤. ì´ë“¤ 경우들ì—ì„œ, ë‹¹ì‹ ì€ ê·¸ ì—”í‹°í‹°ì— ëŒ€í•œ 명시ì ì¸ ìž„ì˜ì˜ ì´ë¦„ì„ ì œê³µí•´ì•¼ 한다. <literal>entity-name</literal> (옵션): Hibernate3는 í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ê°€ (ìž ì •ì 으로 다른 í…Œì´ë¸”들로) 여러 번 매핑ë˜ëŠ” ê²ƒì„ í—ˆìš©í•˜ë©°, ìžë°” ë ˆë²¨ì—ì„œ Map들 ë˜ëŠ” XMLì— ì˜í•´ 표현ë˜ëŠ” 엔티티 ë§¤í•‘ë“¤ì„ í—ˆìš©í•œë‹¤. ì´ë“¤ 경우들ì—ì„œ, ë‹¹ì‹ ì€ ê·¸ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ 명시ì ì¸ ìž„ì˜ì˜ ì´ë¦„ì„ ì œê³µí•´ì•¼ 한다. 추가 ì •ë³´ëŠ” <xref linkend=\"persistent-classes-dynamicmodels\"/>ê³¼ <xref linkend=\"xml\"/>ì„ ë³´ë¼."
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "<literal>check</literal> (옵션): ìžë™ì ì¸ ìŠ¤í‚¤ë§ˆ ìƒì„±ì„ 위한 다중-í–‰ <emphasis>check</emphasis> constraint를 ìƒì„±ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë˜ëŠ” SQL 표현ì‹."
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "<literal>rowid</literal> (옵션): Hibernate는 지ì›ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ë“¤, 예를 들어 Oracle ìƒì—ì„œ ì´ë¥¸ë°” ROWIDë“¤ì„ ì‚¬ìš©í• ìˆ˜ ìžˆê³ , Hibernate는 ë‹¹ì‹ ì´ ì´ ì˜µì…˜ì„ <literal>rowid</literal>ë¡œ ì„¤ì •í•˜ëŠ” ê²½ìš°ì— ë¹ ë¥¸ ì—…ë°ì´íŠ¸ë¥¼ 위한 특별한 <literal>rowid</literal> ì»¬ëŸ¼ì„ ì‚¬ìš©í• ìˆ˜ 있다. ROWID는 구현 ìƒì„¸ì´ê³ ì €ìž¥ëœ íŠœí”Œ(tuple)ì˜ ë¬¼ë¦¬ì ì´ë‹ˆ 위치를 표현한다."
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr "<literal>subselect</literal> (옵션): ë¶ˆë³€ì˜ ì½ê¸° ì „ìš© 엔티티를 ë°ì´í„°ë² ì´ìŠ¤ subselectë¡œ 매핑시킨다. ë‹¹ì‹ ì´ ê¸°ë³¸ í…Œì´ë¸” ëŒ€ì‹ ì— ë·°ë¥¼ ê°–ê³ ìž ì›í• ê²½ìš°ì— ìœ ìš©í•˜ì§€ë§Œ, ì‚¬ìš©ì„ ìžì œí•˜ë¼. 추가 ì •ë³´ëŠ” 아래를 ë³´ë¼."
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr "<literal>abstract</literal> (옵션): <literal><union-subclass></literal> 계층 구조들 ë‚´ì—ì„œ abstract 슈í¼í´ëž˜ìŠ¤ë“¤ì„ 마í¬í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr "ëª…ëª…ëœ ì˜ì† í´ëž˜ìŠ¤ê°€ ì¸í„°íŽ˜ì´ìŠ¤ê°€ ë˜ëŠ” ê²ƒì€ ì™„ì „ížˆ 수용가능하다. 그런 ë‹¤ìŒ ë‹¹ì‹ ì€ <literal><subclass></literal> 요소를 사용하여 ê·¸ ì¸í„°íŽ˜ì´ìŠ¤ì— 대한 구현 í´ëž˜ìŠ¤ë“¤ì„ ì„ ì–¸í• ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ ìž„ì˜ì˜ <emphasis>static</emphasis> inner í´ëž˜ìŠ¤ë¥¼ ì˜ì†í™” 시킬 수 있다. ë‹¹ì‹ ì€ í‘œì¤€ 형ì‹, 예를 들어 <literal>eg.Foo$Bar</literal>를 사용하여 í´ëž˜ìŠ¤ ì´ë¦„ì„ ì§€ì •í•´ì•¼ 한다."
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "ë¶ˆë³€ì˜ í´ëž˜ìŠ¤, <literal>mutable=\"false\"</literal>는 어플리케ì´ì…˜ì— ì˜í•´ ì—…ë°ì´íŠ¸ë˜ì§€ ì•Šì„ ê²ƒì´ê±°ë‚˜ ì‚ì œë˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. ì´ê²ƒì€ Hibernateë¡œ 하여금 ì–´ë–¤ 마ì´ë„ˆ í¼í¬ë¨¼ìŠ¤ 최ì 화를 í–‰í•˜ê²Œë” í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "ì„ íƒì ì¸ <literal>proxy</literal> ì†ì„±ì€ ê·¸ í´ëž˜ìŠ¤ì˜ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 lazy 초기화를 가능하게 해준다. Hibernate는 ëª…ëª…ëœ ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현하는 CGLIB 프ë½ì‹œë“¤ì„ ì´ˆê¸°ì— ë°˜í™˜í• ê²ƒì´ë‹¤. ì‹¤ì œ ì˜ì† ê°ì²´ëŠ” 프ë½ì‹œì˜ 메소드가 호출ë ë•Œ 로드ë 것ì´ë‹¤. 아래 \"Lazy 초기화를 위한 프ë½ì‹œë“¤\"ì„ ë³´ë¼."
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr "<emphasis>Implicit</emphasis> ë‹¤í˜•ì„±ì€ í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ ì–´ë–¤ 서브í´ëž˜ìŠ¤ë‚˜ êµ¬í˜„ëœ ì¸í„°íŽ˜ì´ìŠ¤ ë˜ëŠ” í´ëž˜ìŠ¤ë¥¼ 명명하는 질ì˜ì— ì˜í•´ 반환ë ê²ƒìž„ì„ ì˜ë¯¸í•˜ê³ ê·¸ í´ëž˜ìŠ¤ì˜ ì–´ë–¤ 서브í´ëž˜ìŠ¤ì— 대한 ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ ê·¸ í´ëž˜ìŠ¤ ìžì²´ë¥¼ 명명하는 질ì˜ì— ì˜í•´ 반환ë ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤. <emphasis>Explicit</emphasis> ë‹¤í˜•ì„±ì€ í´ëž˜ìŠ¤ ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ ê·¸ í´ëž˜ìŠ¤ë¥¼ 명시ì 으로 명명하는 질ì˜ë“¤ì— ì˜í•´ì„œë§Œ 반환ë ê²ƒìž„ì„ ì˜ë¯¸ê³ ê·¸ í´ëž˜ìŠ¤ë¥¼ 명명하는 질ì˜ë“¤ì´ ì´ <literal><class></literal> ì„ ì–¸ 내부ì—ì„œ <literal><subclass></literal> ë˜ëŠ” <literal><joined-subclass></literal>ë¡œ ë§¤í•‘ëœ ì„œë¸Œ í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ ë§Œì„ ë°˜í™˜í•˜ê²Œ ë ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤. ëŒ€ë¶€ë¶„ì˜ ìš©ë„ë¡œ, ë””í´íŠ¸ì¸ <literal>polymorphism=\"implicit\"</literal>ê°€ ì ì ˆí•˜ë‹¤.ë‘ ê°œì˜ ë‹¤ë¥¸ í´ëž˜ìŠ¤ë“¤ì´ ë™ì¼í•œ í…Œì´ë¸”ë¡!
œ 매핑ë ë•Œ Explicit ë‹¤í˜•ì„±ì´ ìœ ìš©í•˜ë‹¤(ì´ê²ƒì€ í…Œì´ë¸” ì»¬ëŸ¼ë“¤ì˜ ì„œë¸Œì…‹ì„ í¬í•¨í•˜ëŠ” \"경량급\" í´ëž˜ìŠ¤ë¥¼ 허용한다)."
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr "<literal>persister</literal> ì†ì„±ì€ í´ëž˜ìŠ¤ì— 사용ë˜ëŠ” ì˜ì†í™” ë°©ë„를 ë‹¹ì‹ ì´ ì»¤ìŠ¤íŠ¸ë§ˆì´ì§• í• ìˆ˜ 있ë„ë¡ í•´ì¤€ë‹¤. 예를 들어 ë‹¹ì‹ ì€ <literal>org.hibernate.persister.EntityPersister</literal>ì— ëŒ€í•œ ë‹¹ì‹ ìžì‹ ì˜ ì„œë¸Œí´ëž˜ìŠ¤ë¥¼ ì§€ì •í• ìˆ˜ë„ ìžˆê±°ë‚˜ ë‹¹ì‹ ì€ ì‹¬ì§€ì–´ 예를 들어 플랫 파ì¼ë“¤ì´ë‚˜ LDAPë¡œì˜ ì§ë ¬í™”,내장 í”„ë¡œì‹œì € í˜¸ì¶œë“¤ì„ í†µí•´ ì˜ì†í™”를 구현하는 ì¸í„°íŽ˜ì´ìŠ¤ <literal>org.hibernate.persister.ClassPersister</literal>ì— ëŒ€í•œ ì™„ì „ížˆ 새로운 êµ¬í˜„ì„ ì œê³µí• ìˆ˜ë„ ìžˆë‹¤. (<literal>Hashtable</literal>ë¡œì˜ \"ì˜ì†ì„±\"ì— ê´€í•œ) 간단한 ì˜ˆì œëŠ” <literal>org.hibernate.test.CustomPersister</literal>를 ë³´ë¼."
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr "<literal>dynamic-update</literal> ì„¤ì •ê³¼ <literal>dynamic-insert</literal> ì„¤ì •ì€ ì„œë¸Œí´ëž˜ìŠ¤ë“¤ì— ì˜í•´ ìƒì†ë˜ì§€ ì•Šê³ ë”°ë¼ì„œ ë˜í•œ <literal><subclass></literal> ë˜ëŠ” <literal><joined-subclass></literal> 요소들 ìƒì— ì§€ì •ë ìˆ˜ë„ ìžˆìŒì„ 노트하ë¼. ì´ë“¤ ì„¤ì •ë“¤ì€ ëª‡ëª‡ 경우들ì—ì„œ í¼í¬ë¨¼ìŠ¤ë¥¼ ì¦ê°€ì‹œí‚¤ì§€ë§Œ 다른 경우들ì—서는 í¼í¬ë¨¼ìŠ¤ë¥¼ ì‹¤ì œë¡œ ê°ì†Œì‹œí‚¬ ìˆ˜ë„ ìžˆë‹¤. ì ì ˆí•˜ê²Œ 사용하ë¼."
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "<literal>select-before-update</literal> ì‚¬ìš©ì€ ëŒ€ê°œ í¼í¬ë¨¼ìŠ¤ë¥¼ ê°ì†Œì‹œí‚¬ 것ì´ë‹¤. ë‹¹ì‹ ì´ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ 그래프를 <literal>Session</literal>ì— ë‹¤ì‹œ ì²¨ë¶€í• ê²½ìš°ì— ê·¸ê²ƒì€ ë°ì´í„°ë² ì´ìŠ¤ ì—…ë°ì´íŠ¸ 트리거가 불필요하게 호출ë˜ëŠ” ê²ƒì„ ë°©ì§€í•˜ëŠ”ë° ë§¤ìš° ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr "<literal>dynamic-update</literal>를 사용가능하게 í• ê²½ìš°, ë‹¹ì‹ ì€ ë‹¤ìŒ optimistic ìž ê¸ˆ ì „ëžµë“¤ì„ ì„ íƒí•˜ê²Œ ë 것ì´ë‹¤:"
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr "<literal>version</literal>ì€ version/timestamp ì»¬ëŸ¼ë“¤ì„ ì²´í¬í•œë‹¤"
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr "<literal>all</literal>ì€ ëª¨ë“ ì»¬ëŸ¼ë“¤ì„ ì²´í¬í•œë‹¤"
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr "<literal>dirty</literal>는 몇몇 ë™ì‹œì„± ì—…ë°ì´íŠ¸ë“¤ì„ 허용하여, ë³€ê²½ëœ ì»¬ëŸ¼ë“¤ì„ ì²´í¬í•œë‹¤"
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr "<literal>none</literal>ì€ optimistic ìž ê¸ˆì„ ì‚¬ìš©í•˜ì§€ 않는다"
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr "우리는 ë‹¹ì‹ ì´ Hibernateì—ì„œ optimistic ìž ê¸ˆì„ ìœ„í•´ version/timestamp ì»¬ëŸ¼ë“¤ì„ ì‚¬ìš©í• ê²ƒì„ <emphasis>매우</emphasis> ê°•ë ¥í•˜ê²Œ 권장한다. ì´ê²ƒì€ í¼í¬ë¨¼ìŠ¤ì— 대해 최ì ì˜ ë°©ë„ì´ê³ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대해 행해진 ë³€ê²½ë“¤ì„ ì •í™•í•˜ê²Œ 핸들ë§í•˜ëŠ” ìœ ì¼í•œ ë°©ë„ì´ë‹¤(예를 들어 <literal>Session.merge()</literal>ê°€ 사용ë ë•Œ)."
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "Hibernate ë§¤í•‘ì˜ ê²½ìš°ì— ë² ì´ìŠ¤ í…Œì´ë¸”ê³¼ ë·° 사ì´ì— ì°¨ì´ì ì´ ì¡´ìž¬í•˜ì§€ 않는다. 왜ëƒí•˜ë©´ ì´ê²ƒì´ ë°ì´í„°ë² ì´ìŠ¤ ë ˆë²¨ì—서는 íˆ¬ëª…í•˜ë‹¤ê³ ê¸°ëŒ€ë˜ê¸° 때문ì´ë‹¤(몇몇 DBMS는 뷰를 ê³ ìœ í•˜ê²Œ 지ì›í•˜ì§€ ì•Šê³ íŠ¹ížˆ ë·° ì—…ë°ì´íŠ¸ë¥¼ 지ì›í•˜ì§€ ì•ŠìŒì„ 노트하ë¼). 때때로 ë‹¹ì‹ ì´ ë·°ë¥¼ ì‚¬ìš©í•˜ê³ ìž ì›í•˜ì§€ë§Œ, (예를 들어 리거시 스키마로) ë°ì´í„°ë² ì´ìŠ¤ ì†ì— 뷰를 ìƒì„±ì‹œí‚¬ 수 없다. ì´ ê²½ìš°ì—, ë‹¹ì‹ ì€ ë¶ˆë³€ì˜ ì½ê¸° ì „ìš© 엔티티를 주어진 SQL subselect 표현ì‹ìœ¼ë¡œ 매핑시킬 수 있다:"
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr "auto-flushê°€ ì •í™•í•˜ê²Œ ë°œìƒí•˜ë„ë¡ í•˜ê³ , ê·¸ë¦¬ê³ íŒŒìƒëœ ì—”í‹°í‹°ì— ëŒ€í•œ 질ì˜ë“¤ì´ 쓸효성 없는 ë°ì´í„°ë¥¼ 반환하지 ì•Šë„ë¡ í•¨ìœ¼ë¡œì¨, ì´ ì—”í‹°í‹°ì™€ ë™ê¸°í™” ë í…Œì´ë¸”ì„ ì„ ì–¸í•˜ë¼. <literal><subselect></literal>는 ì†ì„±ê³¼ ë‚´í¬ëœ 매핑 요소 ì–‘ìžë¡œì„œ ì´ìš© 가능하다."
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr "<title>id</title>"
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr "ë§¤í•‘ëœ í´ëž˜ìŠ¤ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키 ì»¬ëŸ¼ì„ ì„ ì–¸<emphasis>해야 한다</emphasis>. ëŒ€ë¶€ë¶„ì˜ í´ëž˜ìŠ¤ë“¤ì€ ë˜í•œ ì¸ìŠ¤í„´ìŠ¤ì˜ ìœ ì¼ ì‹ë³„ìžë¥¼ ì†Œìœ í•˜ëŠ” ìžë°”빈즈-ìŠ¤íƒ€ì¼ í”„ë¡œí¼í‹°ë¥¼ 가질 것ì´ë‹¤. <literal><id></literal> 요소는 ê·¸ 프로í¼í‹°ë¡œë¶€í„° 프ë¼ì´ë¨¸ë¦¬ 키 ì»¬ëŸ¼ìœ¼ë¡œì˜ ë§¤í•‘ì„ ì •ì˜í•œë‹¤."
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr "<literal>name</literal> (옵션): ì‹ë³„ìž í”„ë¡œí¼í‹°ì˜ ì´ë¦„."
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr "<literal>type</literal> (옵션): Hibernate íƒ€ìž…ì„ ë‚˜íƒ€ë‚´ëŠ” ì´ë¦„."
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr "<literal>column</literal> (옵션 - ë””í´íŠ¸ëŠ” 프로í¼í‹° ì´ë¦„): 프ë¼ì´ë¨¸ë¦¬ 키 ì»¬ëŸ¼ì˜ ì´ë¦„."
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr "<literal>unsaved-value</literal> (옵션 - ë””í´íŠ¸ëŠ” \"sensible\" ê°’): ì´ì „ 세션ì—ì„œ ì €ìž¥ë˜ì—ˆê±°ë‚˜ 로드ë˜ì—ˆë˜ detached(분리ëœ) ì¸ìŠ¤í„´ìŠ¤ë“¤ë¡œë¶€í„° ê·¸ê²ƒì„ êµ¬ë¶„ì§€ìš°ë„ë¡, ì¸ìŠ¤í„´ìŠ¤ê°€ ìƒˆë¡œì´ ì´ˆê¸°í™”ë˜ì–´ 있ìŒ(ì €ìž¥ë˜ì–´ 있지 ì•ŠìŒ)ì„ ë‚˜íƒ€ë‚´ëŠ” ì‹ë³„ìž í”„ë¡œí¼í‹° ê°’."
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì•¡ì„¸ìŠ¤í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr "<literal>name</literal> ì†ì„±ì´ 누ë½ë˜ë©´, í´ëž˜ìŠ¤ëŠ” ì‹ë³„ìž í”„ë¡œí¼í‹°ë¥¼ 갖지 ì•ŠëŠ”ë‹¤ê³ ê°€ì •ëœë‹¤."
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr "<literal>unsaved-value</literal> ì†ì„±ì€ Hibernate3ì—서는 ê±°ì˜ í•„ìš”í•˜ì§€ 않다."
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr "composite 키들로서 리거시 ë°ì´í„°ì— 액세스하는 ê²ƒì„ í—ˆìš©í•´ì£¼ëŠ” 대체ì ì¸ <literal><composite-id></literal> ì„ ì–¸ì´ ì¡´ìž¬í•œë‹¤. 우리는 ê·¸ ë°–ì˜ ì–´ë–¤ê²ƒì— ëŒ€í•œ ê·¸ê²ƒì˜ ì‚¬ìš©ì— ëŒ€í•´ ê°•ë ¥í•˜ê²Œ 반대한다."
+
+#: index.docbook:532
+msgid "Generator"
+msgstr "Generator"
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr "ì„ íƒì ì¸ <literal><generator></literal> ìžì‹ 요소는 ì˜ì† í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 ìœ ì¼ ì‹ë³„ìžë“¤ì„ ìƒì„±ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë˜ëŠ” ìžë°” í´ëž˜ìŠ¤ë¥¼ 명명한다. ë§Œì¼ ìž„ì˜ì˜ 파ë¼ë¯¸í„°ë“¤ì´ ìƒì„±ê¸° ì¸ìŠ¤í„´ìŠ¤ë¥¼ 구성하거나 초기화 ì‹œí‚¤ëŠ”ë° í•„ìš”í• ê²½ìš°, ê·¸ê²ƒë“¤ì€ <literal><param></literal> 요소 를 사용하여 ì „ë‹¬ëœë‹¤."
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr "ëª¨ë“ ìƒì„±ê¸°ë“¤ì€ <literal>org.hibernate.id.IdentifierGenerator</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현한다. ì´ê²ƒì€ 매우 간단한 ì¸í„°íŽ˜ì´ìŠ¤ì´ë‹¤; 몇몇 어플리케ì´ì…˜ë“¤ì€ 그것들 ìžì‹ ì˜ íŠ¹í™”ëœ êµ¬í˜„ë“¤ì„ ì œê³µí•˜ë„ë¡ ì„ íƒí• 수 있다. 하지만 Hibernate는 미리 ë¹ˆë“œëœ êµ¬í˜„ë“¤ì˜ ì˜ì—ë“¤ì„ ì œê³µí•œë‹¤. 빌드-ì¸ ìƒì„±ê¸°(generator)ë“¤ì— ëŒ€í•œ 단축 ì´ë¦„ë“¤ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:551
+msgid "increment"
+msgstr "increment"
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "ë™ì¼í•œ í…Œì´ë¸” ì†ìœ¼ë¡œ ë°ì´í„°ë¥¼ ìž…ë ¥í•˜ëŠ” 다른 프로세스가 ì—†ì„ ë•Œì—만 ìœ ì¼í•œ <literal>long</literal>, <literal>short</literal> ë˜ëŠ” <literal>int</literal> íƒ€ìž…ì˜ ì‹ë³„ìžë“¤ì„ ìƒì„±ì‹œí‚¨ë‹¤. <emphasis>í´ëŸ¬ìŠ¤í„° ë‚´ì—서는 사용하지 ë§ë¼.</emphasis>"
+
+#: index.docbook:562
+msgid "identity"
+msgstr "identity"
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "DB2, MySQL, MS SQL Server, Sybase, HypersonicSQLì—ì„œ ì‹ë³„ ì»¬ëŸ¼ë“¤ì„ ì§€ì›í•œë‹¤. 반환ë˜ëŠ” ì‹ë³„ìžëŠ” <literal>long</literal>, <literal>short</literal> ë˜ëŠ” <literal>int</literal> 타입ì´ë‹¤."
+
+#: index.docbook:572
+msgid "sequence"
+msgstr "sequence"
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "DB2, PostgreSQL, Oracle, SAP DB, McKoiì—ì„œ 시퀀스를 사용하거나 Interbaseì—ì„œ ìƒì„±ê¸°(generator)를 사용한다. 반환ë˜ëŠ” ì‹ë³„ìžëŠ” <literal>long</literal>, <literal>short</literal> ë˜ëŠ” <literal>int</literal> 타입ì´ë‹¤."
+
+#: index.docbook:582
+msgid "hilo"
+msgstr "hilo"
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "í…Œì´ë¸”ê³¼ 컬럼(ë””í´íŠ¸ë¡œ ê°ê° <literal>hibernate_unique_key</literal>와 <literal>next_hi</literal>)ì´ hi ê°’ë“¤ì˜ ì†ŒìŠ¤ë¡œì„œ 주어지면, <literal>long</literal>, <literal>short</literal> ë˜ëŠ” <literal>int</literal> íƒ€ìž…ì˜ ì‹ë³„ìžë“¤ì„ 효과ì 으로 ìƒì„±ì‹œí‚¤ëŠ”ë° hi/lo ì•Œê³ ë¦¬ì¦˜ì„ ì‚¬ìš©í•œë‹¤. hi/lo ì•Œê³ ë¦¬ì¦˜ì€ íŠ¹ì • ë°ì´í„°ë² ì´ìŠ¤ì— 대해서만 ìœ ì¼í•œ ì‹ë³„ìžë“¤ì„ ìƒì„±ì‹œí‚¨ë‹¤."
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr "seqhilo"
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "ëª…ëª…ëœ ë°ì´í„°ë² ì´ìŠ¤ 시퀀스가 주어지면, <literal>long</literal>, <literal>short</literal> ë˜ëŠ” <literal>int</literal> íƒ€ìž…ì˜ ì‹ë³„ìžë“¤ì„ 효과ì 으로 ìƒì„±ì‹œí‚¤ëŠ”ë° hi/lo ì•Œê³ ë¦¬ì¦˜ì„ ì‚¬ìš©í•œë‹¤."
+
+#: index.docbook:604
+msgid "uuid"
+msgstr "uuid"
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr "ë„¤íŠ¸ì› ë‚´ì—ì„œ ìœ ì¼í•œ(IP 주소가 사용ëœë‹¤) string íƒ€ìž…ì˜ ì‹ë³„ìžë“¤ì„ ìƒì„±ì‹œí‚¤ê¸° 위해 128 비트 UUID ì•Œê³ ë¦¬ì¦˜ì„ ì‚¬ìš©í•œë‹¤. UUID는 길ì´ê°€ 32ì¸ 16ì§„ìˆ˜ë“¤ì˜ ë¬¸ìžì—´ë¡œì„œ ì¸ì½”딩 ëœë‹¤."
+
+#: index.docbook:614
+msgid "guid"
+msgstr "guid"
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr "MS SQL Server와 MySQL ìƒì—ì„œ ë°ì´í„°ë² ì´ìŠ¤ ìƒì„± GUID 문ìžì—´ì„ 사용한다."
+
+#: index.docbook:622
+msgid "native"
+msgstr "native"
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "기본 ë°ì´í„°ë² ì´ìŠ¤ì˜ ê°€ìš©ì„±ë“¤ì— ì˜ì¡´í•˜ì—¬ <literal>identity</literal>, <literal>sequence</literal> ë˜ëŠ” <literal>hilo</literal>를 찾아낸다."
+
+#: index.docbook:632
+msgid "assigned"
+msgstr "assigned"
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr "어플리케ì´ì…˜ìœ¼ë¡œ 하여금 <literal>save()</literal>ê°€ 호출ë˜ê¸° ì „ì— ì‹ë³„ìžë¥¼ ê°ì²´ì— í• ë‹¹í•˜ë„ë¡ í•œë‹¤. <literal><generator></literal> 요소가 ì§€ì •ë˜ì§€ ì•Šì„ ê²½ìš° ì´ê²ƒì´ ë””í´íŠ¸ ë°©ë„ì´ë‹¤."
+
+#: index.docbook:642
+msgid "select"
+msgstr "select"
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr "ì–´ë–¤ ìœ ì¼ í‚¤ì— ì˜í•´ í–‰ì„ selectí•˜ê³ í”„ë¼ì´ë¨¸ë¦¬ 키 ê°’ì„ ê²€ìƒ‰í•¨ìœ¼ë¡œì¨ ë°ì´í„°ë² ì´ìŠ¤ íŠ¸ë¦¬ê±°ì— ì˜í•´ í• ë‹¹ëœ í”„ë¼ì´ë¨¸ë¦¬ 키를 검색한다."
+
+#: index.docbook:651
+msgid "foreign"
+msgstr "foreign"
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr "ë˜ ë‹¤ë¥¸ ì—°ê´€ëœ ê°ì²´ì˜ ì‹ë³„ìžë¥¼ 사용한다. 대개 <literal><one-to-one></literal> 프ë¼ì´ë¨¸ë¦¬ 키 연관관계와 함께 사용ëœë‹¤."
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr "sequence-identity"
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "ì‹¤ì œ ê°’ ìƒì„±ì„ 위해 ë°ì´í„°ë² ì´ìŠ¤ 시퀀스를 활용하지만, ìƒì„±ëœ ì‹ë³„ìž ê°’ì„ insert 문장 ì‹¤í–‰ì˜ ë¶€ë¶„ìœ¼ë¡œì„œ ì‹¤ì œë¡œ 반환시키기 위해 ì´ê²ƒì„ JDBC3 getGeneratedKeys와 결합시킨 íŠ¹í™”ëœ ì‹œí€€ìŠ¤ ìƒì„± ë°©ë„. ì´ ë°©ë„는 JDK 1.4ì— ëŒ€ìƒí™”ëœ Oracle 10g ë“œë¼ì´ë²„들 ìƒì—서만 지ì›ë˜ëŠ” 거승로 ì•Œë ¤ì ¸ 있다. ì´ë“¤ insert ë¬¸ìž¥ë“¤ì— ëŒ€í•œ 주ì„ë“¤ì€ Oracle ë“œë¼ì´ë²„들 ë‚´ì— ìžˆëŠ” 버그 ë•Œë¬¸ì— ì‚¬ìš©ë¶ˆê°€ëŠ¥í•˜ê²Œ ë˜ì–´ 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr "Hi/lo algorithm"
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr "<literal>hilo</literal>와 <literal>seqhilo</literal> ìƒì„±ê¸°ë“¤ì€ ì‹ë³„ìž ìƒì„±ì— 대한 마ìŒì— 드는 ì ‘ê·¼ë²•ì¸, hi/lo ì•Œê³ ë¦¬ì¦˜ì— ëŒ€í•œ ë‘ ê°œì˜ ëŒ€ì²´ êµ¬í˜„ë“¤ì€ ì œê³µí•œë‹¤. 첫 번째 êµ¬í˜„ì€ ë‹¤ìŒì— ì´ìš© 가능한 \"hi\" ê°’ì„ ìˆ˜ìš©í•˜ê¸° 위한 \"특별한\" ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì„ í•„ìš”ë¡œ 한다. ë‘ ë²ˆì§¸ëŠ” (지ì›ë˜ëŠ”) Oracle 스타ì¼ì˜ 시퀀스를 사용한다."
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "ë¶ˆí–‰ížˆë„ ë‹¹ì‹ ì€ Hibernateì— ë‹¹ì‹ ìžì‹ ì˜ <literal>Connection</literal>ì„ ì œê³µí• ë•Œ <literal>hilo</literal>를 ì‚¬ìš©í• ìˆ˜ 없다. Hibernateê°€ JTAì˜ ë„ì›€ì„ ë°›ëŠ” ì»¤ë„¥ì…˜ë“¤ì„ ì–»ê¸° 위해 어플리케ì´ì…˜ 서버 ë°ì´í„°ì†ŒìŠ¤ë¥¼ ì‚¬ìš©í• ë•Œ ë‹¹ì‹ ì€ <literal>hibernate.transaction.manager_lookup_class</literal>를 ì ì ˆí•˜ê²Œ 구성해야 한다."
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr "UUID ì•Œê³ ë¦¬ì¦˜"
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr "UUID 는 다ìŒì„ í¬í•¨í•œë‹¤: IP 주소, JVMì˜ ì‹œìž‘ 시간(ì •í™•ížˆ 1/4 ì´ˆ), 시스템 시간과 (JVM ë‚´ì—ì„œ ìœ ì¼í•œ) counter ê°’. Java 코드로부터 MAC 주소 ë˜ëŠ” 메모리 주소를 얻는 ê²ƒì€ ë¶ˆê°€ëŠ¥í•˜ì—¬ì„œ, ì´ê²ƒì€ 우리가 JNI를 사용하지 ì•Šê³ ì„œ í–‰í• ìˆ˜ 있는 최ìƒì˜ 것ì´ë‹¤."
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr "ì‹ë³„ 컬럼들과 시퀀스들"
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr "ì‹ë³„ ì»¬ëŸ¼ë“¤ì„ ì§€ì›í•˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ë“¤(DB2, MySQL, Sybase, MS SQL)ì˜ ê²½ìš°, ë‹¹ì‹ ì€ <literal>identity</literal> 키 ìƒì„±ì„ ì‚¬ìš©í• ìˆ˜ 있다. ì‹œí€€ìŠ¤ë“¤ì„ ì§€ì›í•˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ë“¤(DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB)ì˜ ê²½ìš°, ë‹¹ì‹ ì€ <literal>sequence</literal> ìŠ¤íƒ€ì¼ í‚¤ ìƒì„±ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤. ì´ë“¤ ë°©ë„들 ëª¨ë‘ ìƒˆë¡œìš´ ê°ì²´ë¥¼ insert하기 위해 ë‘ ê°œì˜ SQL 질ì˜ë“¤ì„ 필요로 한다."
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr "í¬ë¡œìŠ¤ í”Œëž«í¼ ê°œë°œì„ ìœ„í•´ì„œ, <literal>native</literal> ë°©ë„ê°€ 기준 ë°ì´í„°ë² ì´ìŠ¤ë“¤ì˜ ê°€ìš©ì„±ë“¤ì— ë”°ë¼ <literal>identity</literal>, <literal>sequence</literal>, <literal>hilo</literal> ë°©ë„ ì¤‘ì—ì„œ ì„ íƒë 것ì´ë‹¤."
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr "í• ë‹¹ëœ ì‹ë³„ìžë“¤"
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr "(Hibernateë¡œ 하여금 ì‹ë³„ìžë“¤ì„ ìƒì„±ì‹œí‚¤ë„ë¡ í•˜ëŠ” 것과는 반대로) ë‹¹ì‹ ì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ìœ¼ë¡œ 하여금 ì‹ë³„ìžë“¤ì„ í• ë‹¹í•˜ë„ë¡ ì›í• 경우, ë‹¹ì‹ ì€ <literal>assigned</literal> ìƒì„±ê¸°ë¥¼ ì‚¬ìš©í• ìˆ˜ 있다. ì´ íŠ¹ë³„í•œ ìƒì„±ê¸°ëŠ” ê°ì²´ì˜ identifier 프로í¼í‹°ì— ì´ë¯¸ í• ë‹¹ëœ ì‹ë³„ìž ê°’ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. ì´ ìƒì„±ê¸°(generator)는 프ë¼ì´ë¨¸ë¦¬ 키가 대용(surrogate ) 키 ëŒ€ì‹ ì— natural í‚¤ì¼ ë•Œ 사용ëœë‹¤. ë‹¹ì‹ ì´ <literal><generator></literal> 요소를 ì§€ì •í•˜ì§€ ì•Šì„ ê²½ìš°ì— ì´ê²ƒì´ ë””í´íŠ¸ 특징ì´ë‹¤"
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr "<literal>assigned</literal> ìƒì„±ê¸°(generator)를 ì„ íƒí•˜ëŠ” ê²ƒì€ , version ë˜ëŠ” timestamp 프로í¼í‹°ê°€ 존재하지 않는 í•œ ë˜ëŠ” ë‹¹ì‹ ì´ <literal>Interceptor.isUnsaved()</literal>를 ì •ì˜í•˜ì§€ 않는 í•œ, í•˜ë‚˜ì˜ ì¸ìŠ¤í„´ìŠ¤ê°€ transient ë˜ëŠ” detachedì¸ì§€ë¥¼ ê²°ì •í•˜ê¸° 위해 Hibernaeë¡œ 하여금 ë°ì´í„°ë² ì´ìŠ¤ì— ì ‘ì´‰í•˜ë„ë¡ ê°•ì œí•˜ëŠ”, <literal>unsaved-value=\"undefined\"</literal>를 Hibernateì—게 사용하ë„ë¡ í•œë‹¤."
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr "íŠ¸ë¦¬ê±°ë“¤ì— ì˜í•´ í• ë‹¹ëœ í”„ë¼ì´ë¨¸ë¦¬ 키들"
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr "리거시 ìŠ¤í‚¤ë§ˆì— ëŒ€í•´ì„œë§Œ(Hibernate는 íŠ¸ë¦¬ê±°ë“¤ì„ ê°€ì§„ DDLì„ ìƒì„±ì‹œí‚¤ì§€ 않는다)."
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr "ìœ„ì˜ ì˜ˆì œì—ì„œ, natural 키로서 í´ëž˜ìŠ¤ì— ì˜í•´ <literal>socialSecurityNumber</literal>ë¡œ ëª…ëª…ëœ ìœ ì¼ ê°’ì„ ê°€ì§„ 프로í¼í‹°ê°€ ì¡´ìž¬í•˜ê³ , íŠ¸ë¦¬ê±°ì— ì˜í•´ ê·¸ ê°’ì´ ìƒì„±ë˜ëŠ” <literal>person_id</literal>ë¡œ ëª…ëª…ëœ ëŒ€ìš©í‚¤ê°€ 존재한다."
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr "composite-id"
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr "composite 키를 가진 í…Œì´ë¸”ì˜ ê²½ìš°, ë‹¹ì‹ ì€ í´ëž˜ìŠ¤ì˜ 여러 프로í¼í‹°ë“¤ì„ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ë¡œì„œ ë§¤í•‘í• ìˆ˜ 있다. <literal><composite-id></literal> 요소는 ìžì‹ 요소들로서 <literal><key-property></literal> 프로í¼í‹° 매핑과 <literal><key-many-to-one></literal> ë§¤í•‘ë“¤ì„ í—ˆìš©í•œë‹¤."
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr "ë‹¹ì‹ ì˜ ì˜ì† í´ëž˜ìŠ¤ëŠ” composite ì‹ë³„ìž ë™ë“±ì„±ì„ 구현하기 위해서 <literal>equals()</literal>와 <literal>hashCode()</literal>를 오버ë¼ì´ë“œ <emphasis>시켜야 한다</emphasis>. ê·¸ê²ƒì€ ë˜í•œ <literal>Serializable</literal>ì„ êµ¬í˜„í•´ì•¼ 한다."
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr "불행히ë„, composite ì‹ë³„ìžë“¤ì— 대한 ì´ ì ‘ê·¼ë²•ì€ ì˜ì† ê°ì²´ê°€ 그것 ìžì‹ ì˜ ì‹ë³„ìžë¼ëŠ” ì ì„ ì˜ë¯¸í•œë‹¤. ê°ì²´ ìžì‹ ì™¸ì˜ ë‹¤ë¥¸ \"핸들\"ì´ ì¡´ìž¬í•˜ì§€ 않는다. ë‹¹ì‹ ì€ ë‹¹ì‹ ì´ composite keyë¡œ ì—°ê´€ëœ ì˜ì† ìƒíƒœë¥¼ <literal>load()</literal> í• ìˆ˜ 있기 ì´ì „ì— ì˜ì† í´ëž˜ìŠ¤ ê·¸ ìžì²´ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 초기화 í•˜ê³ ê·¸ê²ƒì˜ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ 군집화 시켜야 한다. 우리는 ì´ ì ‘ê·¼ë²•ì„ <emphasis>embedded</emphasis> composite ì‹ë³„ìžë¡œ ë¶€ë¥´ê³ , 중대한 어플리케ì´ì…˜ë“¤ì— 대해 ê·¸ê²ƒì„ ì–µì œì‹œí‚¨ë‹¤."
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "ë‘ ë²ˆì§¸ ì ‘ê·¼ë²•ì€ ìš°ë¦¬ê°€ <emphasis>mapped</emphasis> composite ì‹ë³„ìžë¼ê³ 부르는 것ì¸ë°, 여기서 <literal><composite-id></literal> 요소 ë‚´ì— ëª…ëª…ëœ ì—¬ê¸°ì„œ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì€ ì˜ì† í´ëž˜ìŠ¤ì™€ 별ë„ì˜ ì‹ë³„ìž í´ëž˜ìŠ¤ ì–‘ìž ìƒì— 중복ëœë‹¤."
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr "ì´ ì˜ˆì œì—ì„œ, composite ì‹ë³„ìž í´ëž˜ìŠ¤ì¸ <literal>MedicareId</literal>와 엔티티 í¬ëž˜ìŠ¤ ê·¸ ìžì²´ ì–‘ìžëŠ” <literal>medicareNumber</literal>와 <literal>dependent</literal>ë¡œ ëª…ëª…ëœ í”„ë¡œí¼í‹°ë“¤ì„ 갖는다. ì‹ë³„ìž í´ëž˜ìŠ¤ëŠ” <literal>equals()</literal>와 <literal>hashCode()</literal>를 오버ë¼ì´ë“œ ì‹œì¼œê³ <literal>Serializable</literal>ì„ êµ¬í˜„í•´ì•¼ 한다. ì´ ì ‘ê·¼ë²•ì˜ ë‹¨ì ì€ ì•„ì£¼ 명백한—코드 중복ì´ë‹¤."
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "ë‹¤ìŒ ì†ì„±ë“¤ì€ ë§¤í•‘ëœ composite ì‹ë³„ìžë¥¼ ì§€ì •í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤:"
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr "<literal>mapped</literal> (옵션, ë””í´íŠ¸ëŠ” <literal>false</literal>): í•˜ë‚˜ì˜ ë§¤í•‘ëœ composite ì‹ë³„ìžê°€ 사용ë¨ì„, ê·¸ë¦¬ê³ í¬í•¨ëœ 프로í¼í‹° ë§¤í•‘ë“¤ì´ ì—”í‹°í‹° í´ëž˜ìŠ¤ì™€ composite ì‹ë³„ìž í´ëž˜ìŠ¤ ì–‘ìžë¥¼ ì°¸ì¡°í•¨ì„ ë‚˜íƒ€ë‚¸ë‹¤."
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr "<literal>class</literal> (옵션, 하지만 í•˜ë‚˜ì˜ ë§¤í•‘ëœ commposite ì‹ë³„ìžì— 대해서는 필수ì ìž„): í•˜ë‚˜ì˜ composite ì‹ë³„ìžë¡œì„œ 사용ë˜ëŠ” í´ëž˜ìŠ¤."
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr "우리는 <xref linkend=\"components-compositeid\"/>ì—ì„œ composite ì‹ë³„ìžê°€ í•˜ë‚˜ì˜ component í´ëž˜ìŠ¤ë¡œì„œ 구현ë˜ëŠ” 보다 편리한 ì ‘ê·¼ë²•ì¸ ì„¸ë²ˆì§¸ ë°©ë„를 ì„¤ëª…í• ê²ƒì´ë‹¤. ì•„ëž˜ì— ì„¤ëª…ë˜ì–´ 있는 ì†ì„±ë“¤ì€ ì´ ëŒ€ì²´ì ì¸ ì ‘ê·¼ë²•ì—만 ì ìš©ëœë‹¤:"
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr "<literal>name</literal> (옵션, ì´ ì ‘ê·¼ë²•ì˜ ê²½ìš°ì—는 필수임): í•˜ë‚˜ì˜ component ì‹ë³„ìžë¥¼ ì†Œìœ í•˜ëŠ” ì»´í¬ë„ŒíŠ¸ íƒ€ìž…ì˜ í”„ë¡œí¼í‹°(9ìž¥ì„ ë³´ë¼)."
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr "<literal>class</literal> (옵션 - ë””í´íŠ¸ëŠ” reflectionì— ì˜í•´ ê²°ì •ëœ í”„ë¡œí¼í‹° 타입): í•˜ë‚˜ì˜ composite ì‹ë³„ìžë¡œì„œ 사용ë˜ëŠ” ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤(ë‹¤ìŒ ì ˆì„ ë³´ë¼)."
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr "ì´ ì„¸ë²ˆì§¸ ì ‘ê·¼ë²•, <emphasis>identifier component</emphasis>ì€ ê±°ì˜ ëª¨ë“ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì— 대해 우리가 권장하는 것ì´ë‹¤."
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr "discriminator"
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr "<literal><discriminator></literal> 요소는 table-per-class-hierarchy(í…Œì´ë¸” 당 í´ëž˜ìŠ¤ 계층구조) 매핑 ë°©ë„를 사용하는 다형성 ì˜ì†í™”ì— í•„ìš”í•˜ê³ í…Œì´ë¸”ì˜ discriminator(íŒë³„ìž) ì»¬ëŸ¼ì„ ì„ ì–¸í•œë‹¤. discriminator ì»¬ëŸ¼ì€ íŠ¹ì • í–‰ì— ëŒ€í•´ 초기화 시킬 서브 í´ëž˜ìŠ¤ê°€ 무엇ì¸ì§€ë¥¼ ì˜ì† ê³„ì¸µì— ì•Œë ¤ì£¼ëŠ” í‘œì‹œìž ê°’ë“¤ì„ í¬í•¨í•œë‹¤. íƒ€ìž…ë“¤ì˜ ì œí•œì ì¸ ì§‘í•©ì´ ì‚¬ìš©ë 수 있다: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr "<literal>column</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>class</literal>) discriminator 컬럼명."
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr "<literal>type</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>string</literal>) Hibernate íƒ€ìž…ì„ ë‚˜íƒ€ë‚´ëŠ” ì´ë¦„"
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr "<literal>force</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>) ì´ê²ƒì€ Hibernateë¡œ 하여금 루트 í´ëž˜ìŠ¤ì˜ ëª¨ë“ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ê²€ìƒ‰í• ë•Œì¡°ì°¨ë„ í—ˆìš©ëœ discriminator ê°’ë“¤ì„ ì§€ì •í•˜ë„ë¡ \"ê°•ì œí•œë‹¤\"."
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr "<literal>insert</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>) ë‹¹ì‹ ì˜ discriminator ì»¬ëŸ¼ì´ ë˜í•œ ë§¤í•‘ëœ composite ì‹ë³„ìžì˜ ë¶€ë¶„ì¼ ê²½ìš°ì— ì´ê²ƒì„ <literal>false</literal>ë¡œ ì„¤ì •í•˜ë¼. (Hibernateì—게 SQL <literal>INSERT</literal>들 ì†ì— ê·¸ ì»¬ëŸ¼ì„ í¬í•¨í•˜ì§€ ì•Šë„ë¡ í†µë³´í•œë‹¤.)"
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr "<literal>formula</literal> (옵션) íƒ€ìž…ì´ í‰ê°€ ë˜ì–´ì•¼ í• ë•Œ 실행ë˜ëŠ” ìž„ì˜ì˜ SQL 표현ì‹. 컨í…ì¸ ê¸°ë°˜ì˜ íŒë³„ì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr "discriminator ì»¬ëŸ¼ì˜ ì‹¤ì œ ê°’ë“¤ì€ <literal><class></literal> 요소와 <literal><subclass></literal> ìš”ì†Œì˜ <literal>discriminator-value</literal> ì†ì„±ì— ì˜í•´ ì§€ì •ëœë‹¤."
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal>force</literal> ì†ì„±ì€ í…Œì´ë¸”ì´ ì˜ì† í´ëž˜ìŠ¤ë¡œ 매핑ë˜ì§€ 않는 \"특별한\" discriminator ê°’ë“¤ì„ ê°€ì§„ í–‰ë“¤ì„ í¬í•¨í• 경우ì—(만) ìœ ìš©í•˜ë‹¤. ì´ê²ƒì€ 대개 ê·¸ 경우가 ì•„ë‹ ê²ƒì´ë‹¤."
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr "<literal>formula</literal> ì†ì„±ì„ 사용하여 ë‹¹ì‹ ì€ í–‰ì˜ íƒ€ìž…ì„ íŒë‹¨í•˜ëŠ”ë° ì‚¬ìš©ë ìž„ì˜ì˜ SQL 표현ì‹ì„ ì„ ì–¸í• ìˆ˜ 있다:"
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr "version (옵션)"
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr "<literal><version></literal> 요소는 옵션ì´ê³ í…Œì´ë¸”ì´ ë²„ì „í™”ëœ ë°ì´í„°ë¥¼ í¬í•¨í•œë‹¤ëŠ” ê²ƒì„ ë‚˜íƒ€ë‚¸ë‹¤. ì´ê²ƒì€ ë‹¹ì‹ ì´ <emphasis>긴 트랜ìžì…˜(long transaction)들</emphasis>ì„ ì‚¬ìš©í• ê³„íšì´ë¼ë©´ 특히 ìœ ìš©í•˜ë‹¤ (아래를 ë³´ë¼)."
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr "<literal>column</literal> (옵션 - ë””í´íŠ¸ëŠ” 프로í¼í‹° 명): ë²„ì „ 번호를 가진 ì»¬ëŸ¼ì˜ ì´ë¦„."
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "<literal>name</literal>: ì˜ì† í´ëž˜ìŠ¤ì˜ 프로í¼í‹° 명."
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr "<literal>type</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>integer</literal>): ë²„ì „ ë²ˆí˜¸ì˜ íƒ€ìž…."
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì•¡ì„¸ìŠ¤í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr "<literal>unsaved-value</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>undefined</literal>): ì´ì „ 세션ì—ì„œ ì €ìž¥ë˜ì—ˆê±°ë‚˜ 로드ë˜ì—ˆë˜ detached ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° 구별지어서, ì¸ìŠ¤í„´ìŠ¤ê°€ ìƒˆë¡œì´ ì´ˆê¸°í™”ë¨(unsaved)ì„ ë‚˜íƒ€ë‚´ëŠ” version 프로í¼í‹° ê°’.(<literal>undefined</literal>는 ì‹ë³„ìž í”„ë¡œí¼í‹° ê°’ì´ ì‚¬ìš©ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤.)"
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr "<literal>insert</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): version ì»¬ëŸ¼ì´ SQL insert 문장들 ì†ì— í¬í•¨ë 것ì¸ì§€ 여부를 ì§€ì •í•œë‹¤. ë°ì´í„°ë² ì´ìŠ¤ ì»¬ëŸ¼ì´ ë””í´íŠ¸ ê°’ <literal>0</literal>으로 ì •ì˜ë˜ëŠ” 경우ì—만 <literal>false</literal>ë¡œ ì„¤ì •ë 수 있다."
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr "ë²„ì „ ë²ˆí˜¸ë“¤ì€ <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> ë˜ëŠ” <literal>calendar</literal> íƒ€ìž…ì¼ ìˆ˜ 있다."
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr "version ë˜ëŠ” timestamp 프로í¼í‹°ëŠ” detached ì¸ìŠ¤í„´ìŠ¤ì— 대해 ê²°ì½” nullì¼ ìˆ˜ê°€ 없어서, Hibernate는 다른 <literal>unsaved-value</literal> ë°©ë„ë“¤ì´ ì§€ì •ë˜ëŠ” ê²ƒì— ìƒê´€ì—†ì´, null versionì´ë‚˜ timestamp를 가진 ìž„ì˜ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ transient로서 ê²€ì¶œí• ê²ƒì´ë‹¤. <emphasis>null 허용ë˜ëŠ” version ì´ë‚˜ property를 ì„ ì–¸í•˜ëŠ” ê²ƒì€ Hibernateì—ì„œ transitive reattachmentì— ëŒ€í•œ ìž„ì˜ì˜ ë¬¸ì œë“¤ì„ í”¼í•˜ëŠ” 쉬운 방법ì´ê³ , assigned ì‹ë³„ìžë“¤ì´ë‚˜ composite keyë“¤ì„ ì‚¬ìš©í•˜ëŠ” 사람들ì—게 특히 ìœ ìš©í•˜ë‹¤!</emphasis>"
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr "timestamp (옵션)"
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr "옵션 <literal><timestamp></literal> 요소는 í…Œì´ë¸”ì´ íƒ€ìž„ìŠ¤íƒ¬í”„í™” ëœ ë°ì´í„°ë¥¼ í¬í•¨í•¨ì„ 나타낸다. ì´ê²ƒì€ ë²„ì „í™”ì— ëŒ€í•œ 대체물로서 ê³ ì•ˆë˜ì—ˆë‹¤. Timestampì€ ê³ ìœ í•˜ê²Œ optimistic ìž ê¸ˆì— ëŒ€í•œ 다소 ì•ˆì „í•œ 구현ì´ë‹¤. 하지만 때때로 어플리케ì´ì…˜ì€ 다른 방법들로 timestampë“¤ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr "<literal>column</literal> (옵션 - ë””í´íŠ¸ëŠ” 프로í¼í‹° 명): 타임스탬프를 í¬í•¨í•˜ëŠ” 컬럼 명."
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr "<literal>name</literal>: ì˜ì† í´ëž˜ìŠ¤ì— 대해 ìžë°” <literal>Date</literal> ë˜ëŠ” <literal>Timestamp</literal> íƒ€ìž…ì„ ê°€ì§„ ìžë°”빈즈 스타ì¼ì˜ 프로í¼í‹° ì´ë¦„."
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr "<literal>unsaved-value</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>null</literal>): ì´ì „ 세션ì—ì„œ ì €ìž¥ë˜ì—ˆê±°ë‚˜ 로드ë˜ì—ˆë˜ detached ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° ì¸ìŠ¤í„´ìŠ¤ë¥¼ 구별지우는, ì¸ìŠ¤í„´ìŠ¤ê°€ ìƒˆë¡œì´ ì´ˆê¸°í™”ë¨(unsaved)ì„ ë‚˜íƒ€ë‚´ëŠ” version 프로í¼í‹° ê°’.(<literal>undefined</literal>는 ì‹ë³„ìž í”„ë¡œí¼í‹° ê°’ì´ ì‚¬ìš©ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤.)"
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr "<literal>source</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>vm</literal>): Hibernate는 어디서 timestamp ê°’ì„ ê²€ìƒ‰í• ê²ƒì¸ê°€? ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„°ì¸ê°€ í˜„ìž¬ì˜ JVM으로부터ì¸ê°€? ë°ì´í„°ë² ì´ìŠ¤ ê¸°ë°˜ì˜ timestampë“¤ì€ Hibernateê°€ \"ë‹¤ìŒ ê°’\"ì„ ê²°ì •í•˜ê¸° 위해 ë°ì´í„°ë² ì´ìŠ¤ì— ì ‘ì†í•´ì•¼ 하기 ë•Œë¬¸ì— ì˜¤ë²„í—¤ë“œë¥¼ 초래하지만, í´ëŸ¬ìŠ¤í„°ë§ëœ 환경들ì—ì„œì˜ ìš©ë„ë¡œ 보다 ë” ì•ˆì „í• ê²ƒì´ë‹¤. ë˜í•œ ëª¨ë“ <literal>Dialect</literal>ë“¤ì´ ë°ì´í„°ë² ì´ìŠ¤ì˜ í˜„ìž¬ì˜ timestampì— ëŒ€í•œ ê²€ìƒ‰ì„ ì§€ì›í•˜ëŠ” 것으로 ì•Œë ¤ì ¸ 있지 않지만, 다른 <literal>Dialect</literal>ë“¤ì€ ì •ë°€ë„ ê²°í• ë•Œë¬¸ì— ìž ê¸ˆì— ìžˆì–´ ì‚¬ìš©ì´ ì•ˆì „í•˜ì§€ ì•Šì„ ìˆ˜ 있ìŒì„ 노트하ë¼(예를 들면 오ë¼í´ 8)."
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "<literal>generated</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>never</literal>): ì´ timestamp 프로í¼í‹° ê°’ì´ ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ ì‹¤ì œë¡œ ìƒì„±ë¨ì„ ì§€ì •í•œë‹¤. <xref linkend=\"mapping-generated\"/>산출ë˜ëŠ” 프로í¼í‹°ë“¤ì— 대한 ë…¼ì˜ë“¤ ë³´ë¼."
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr "<literal><timestamp></literal>는 <literal><version type=\"timestamp\"></literal>ê³¼ ê°™ìŒì„ 노트하ë¼. ê·¸ë¦¬ê³ <literal><timestamp use-db=\"true\"></literal>는 <literal><version type=\"dbtimestamp\"></literal>ê³¼ 같다"
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr "프로í¼í‹°"
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr "<literal><property></literal> 요소는 í´ëž˜ìŠ¤ì˜ ìžë°”빈즈 스타ì¼ì˜ ì˜ì† 프로í¼í‹°ë¥¼ ì„ ì–¸í•œë‹¤."
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "<literal>name</literal>: 첫 소문ìžë¡œ 시작하는 프로í¼í‹° ì´ë¦„."
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr "<literal>column</literal> (옵션 - ë””í´íŠ¸ëŠ” 프로í¼í‹° ì´ë¦„): ë§¤í•‘ëœ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸” ì»¬ëŸ¼ì˜ ì´ë¦„. ì´ê²ƒì€ ë˜í•œ ë‚´ë¶€ì— í¬í•¨ë˜ëŠ” <literal><column></literal> 요소(들)ì— ì˜í•´ ì§€ì •ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr "<literal>type</literal> (옵션): Hibernate íƒ€ìž…ì„ ë‚˜íƒ€ë‚´ëŠ” ì´ë¦„."
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr "<literal>update, insert</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>) : ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ <literal>UPDATE</literal>와/ë˜ëŠ” <literal>INSERT</literal> 문장들ì†ì— í¬í•¨ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤. 둘다 <literal>false</literal>ë¡œ ì„¤ì •í•˜ëŠ” ê²ƒì€ ê·¸ ê°’ì´ ë™ì¼í•œ 컬럼(들)ë¡œ 매핑ë˜ëŠ” ì–´ë–¤ 다른 프로í¼í‹°ë¡œë¶€í„° ë˜ëŠ” íŠ¸ë¦¬ê±°ì— ì˜í•´ ë˜ëŠ” 다른 어플리케ì´ì…˜ìœ¼ë¡œë¶€í„° 초기화 ë˜ëŠ” 순수하게 \"파ìƒëœ(derived)\" 프로í¼í‹°ë¥¼ 허용해준다."
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ì¸ìŠ¤í„´ìŠ¤ 변수가 처ìŒìœ¼ë¡œ 액세스 ë ë•Œ ì´ í”„ë¡œí¼í‹°ê°€ lazily하게 페치ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤(빌드-ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 한다)."
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr "<literal>unique</literal> (옵션): ì»¬ëŸ¼ë“¤ì— ëŒ€í•œ ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ DDL ìƒì„±ì„ 가능하게 ë§Œë“ ë‹¤. ë˜í•œ ì´ê²ƒì´ <literal>property-ref</literal>ì˜ íƒ€ì¼“ì´ ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "<literal>not-null</literal> (옵션): ì»¬ëŸ¼ë“¤ì— ëŒ€í•´ null 가능 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ DDL ìƒì„±ì„ 가능하게 ë§Œë“ ë‹¤."
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì´ í”„ë¡œí¼í‹°ì— 대한 ì—…ë°ì´íŠ¸ë“¤ì´ optimistic ìž ê¸ˆì„ íšë“하는 ê²ƒì„ í•„ìš”ë¡œ 하거나 필요로 하지 ì•ŠìŒì„ ì§€ì •í•œë‹¤. 달리ë§í•´, ì´ í”„ë¡œí¼í‹°ê°€ dirtyì¼ ë•Œ ë²„ì „ ì¦ê°€ê°€ ë°œìƒí• 경우ì¸ì§€ë¥¼ ê²°ì •í•œë‹¤."
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr "<literal>generated</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>never</literal>): ì´ í”„ë¡œí¼í‹° ê°’ì´ ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ ì‹¤ì œë¡œ 산출ë˜ëŠ”지를 ì§€ì •í•œë‹¤. <xref linkend=\"mapping-generated\"/>산출ë˜ëŠ” 프로í¼í‹°ë“¤ì— 대한 ë…¼ì˜ë¥¼ ë³´ë¼."
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr "<emphasis>typename</emphasis>ì€ ë‹¤ìŒì¼ 수 있다:"
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr "Hibernate 기본 íƒ€ìž…ì˜ ì´ë¦„ (예를 들어. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr "ë””í´íŠ¸ 기본 íƒ€ìž…ì„ ê°€ì§„ Java í´ëž˜ìŠ¤ì˜ ì´ë¦„(예를 들어. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "serializable Java í´ëž˜ìŠ¤ì˜ ì´ë¦„."
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ íƒ€ìž…ì„ ì§€ì •í•˜ì§€ ì•Šì„ ê²½ìš°, Hibernate는 ì •í™•í•œ Hibernate íƒ€ìž…ì„ ì¶”ì •í•˜ê¸° 위해 ëª…ëª…ëœ í”„ë¡œí¼í‹°ì— 대해 reflectionì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. Hibernate는 ê·¸ 순서ì—ì„œ 2,3,4 ê·œì¹™ë“¤ì„ ì‚¬ìš©í•˜ì—¬ 프로í¼í‹° getterì˜ ë°˜í™˜ í´ëž˜ìŠ¤ì˜ ì´ë¦„ì„ í•´ì„í•˜ë ¤ê³ ì‹œë„í• ê²ƒì´ë‹¤. 하지만 ì´ê²ƒì€ í•ìƒ 충분하지는 않다. ì–´ë–¤ 경우들ì—ì„œ, ë‹¹ì‹ ì€ ì—¬ì „ížˆ <literal>type</literal> ì†ì„±ì„ 필요로 í• ê²ƒì´ë‹¤.(예를 들어, <literal>Hibernate.DATE</literal>와 <literal>Hibernate.TIMESTAMP</literal> 사ì´ë¥¼ 구별하기 위해, ë˜ëŠ” 맞춤 íƒ€ìž…ì„ ì§€ì •í•˜ê¸° 위해.)"
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr "<literal>access</literal> ì†ì„±ì€ ë‹¹ì‹ ìœ¼ë¡œ 하여금 Hibernateê°€ 런타임 ì‹œì— í”„ë¡œí¼í‹°ì— 액세스하는 ë°©ë²•ì„ ì œì–´í•˜ë„ë¡ í•´ì¤€ë‹¤. ë””í´íŠ¸ë¡œ Hibernate는 프로í¼í‹° get/set ìŒì„ í˜¸ì¶œí• ê²ƒì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ <literal>access=\"field\"</literal>를 ì§€ì •í• ê²½ìš°, Hibernate는 get/set ìŒì„ í”¼í•˜ê³ reflectionì„ ì‚¬ìš©í•˜ì—¬ ì§ì ‘ í•„ë“œì— ì•¡ì„¸ìŠ¤ í• ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ <literal>org.hibernate.property.PropertyAccessor</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현하는 í´ëž˜ìŠ¤ë¥¼ ëª…ëª…í•¨ìœ¼ë¡œì¨ í”„ë¡œí¼í‹° ì ‘ê·¼ì„ ìœ„í•œ ë‹¹ì‹ ìžì‹ ì˜ ë°©ë„를 ì§€ì •í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "특별히 ê°•ë ¥í•œ íŠ¹ì§•ì€ íŒŒìƒëœ 플로í¼í‹°ë“¤ì´ë‹¤. ì´ë“¤ 프로í¼í‹°ë“¤ì€ ì •ì˜ìƒ ì½ê¸° ì „ìš©ì´ê³ , ê·¸ 프로í¼í‹° ê°’ì€ ë¡œë“œ ì‹œì— ê³„ì‚°ëœë‹¤. ë‹¹ì‹ ì€ ê·¸ ê³„ì‚°ì„ SQL 표현ì‹ìœ¼ë¡œ ì„ ì–¸í•˜ê³ , ì´ê²ƒì€ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 로드시키는 SQL ì§ˆì˜ ë‚´ì˜ <literal>SELECT</literal> ì ˆ 서브질ì˜ë¡œ 번ì—ëœë‹¤:"
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+
+#: index.docbook:1284
+msgid "property"
+msgstr "ë‹¹ì‹ ì€ íŠ¹ì • 컬럼(주어진 ì˜ˆì œì—서는 <literal>customerId</literal>)ì— ëŒ€í•´ alias를 ì„ ì–¸í•˜ì§€ ì•ŠìŒìœ¼ë¡œì¨ 엔티티들 ìžì‹ ì˜ í…Œì´ë¸”ì„ ì°¸ì¡°í• ìˆ˜ 있ìŒì„ 노트하ë¼. ë˜í•œ ë‹¹ì‹ ì€ ë§Œì¼ ë‹¹ì‹ ì´ ê·¸ ì†ì„±ì„ ì‚¬ìš©í•˜ê³ ì‹¶ì§€ ì•Šì„ ê²½ìš°ì— ë‚´í¬ëœ <literal><formula></literal> 매핑 요소를 ì‚¬ìš©í• ìˆ˜ 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr "many-to-one"
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr "ë˜ ë‹¤ë¥¸ ì˜ì† í´ëž˜ìŠ¤ì— 대한 ì •ê·œ 연관관계는 <literal>many-to-one</literal> 요소를 사용하여 ì„ ì–¸ëœë‹¤. 관계형 ëª¨í˜•ì€ many-to-one 연관관계ì´ë‹¤.: í•˜ë‚˜ì˜ í…Œì´ë¸” ë‚´ì— ìžˆëŠ” foreign 키는 ëŒ€ìƒ í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키 컬럼(들)ì„ ì°¸ì¡°í•˜ê³ ìžˆë‹¤."
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>name</literal>: 프로í¼í‹°ì˜ ì´ë¦„."
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr "<literal>column</literal> (옵션): foreign key ì»¬ëŸ¼ì˜ ì´ë¦„. ì´ê²ƒì€ ë˜í•œ ë‚´í¬ëœ <literal><column></literal> 요소(들)ì— ì˜í•´ ì§€ì •ëœë‹¤."
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr "<literal>class</literal> (옵션 - ë””í´íŠ¸ëŠ” reflectionì— ì˜í•´ ê²°ì •ëœ í”„ë¡œí¼í‹° 타입): ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ ì´ë¦„."
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "<literal>cascade</literal> (옵션): ì–´ëŠ ì˜¤í¼ë ˆì´ì…˜ë“¤ì´ 부모 ê°ì²´ë¡œë¶€í„° ì—°ê´€ëœ ê°ì²´ë¡œ 케스케ì´ë“œ ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>update, insert</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>) ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ SQL <literal>UPDATE</literal>와/ë˜ëŠ” <literal>INSERT</literal> 문장들 ì†ì— í¬í•¨ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤. 둘다 <literal>false</literal>ë¡œ ì„¤ì •í•˜ëŠ” ê²ƒì€ ê·¸ ê°’ì´ ë™ì¼í•œ 컬럼(들)ë¡œ 매핑시키는 ì–´ë–¤ 다른 컬럼들로부터 초기화 ë˜ê±°ë‚˜ 트리거나 다른 어플리케ì´ì…˜ì— ì˜í•´ 초기화ë˜ëŠ” 단순한 \"파ìƒëœ\" 연관관계 ê°’ì„ í—ˆìš©í•œë‹¤."
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>property-ref</literal>: (옵션) ì´ foreign keyì— ì¡°ì¸ë˜ëŠ” ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ 프로í¼í‹° ì´ë¦„. ì§€ì •ë˜ì§€ ì•Šì„ ê²½ìš°, ì—°ê´€ í´ëž˜ìŠ¤ì˜ 프ë¼ì´ë¨¸ë¦¬ 키가 사용ëœë‹¤."
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "<literal>unique</literal> (옵션): foreign-key ì»¬ëŸ¼ì„ ìœ„í•œ ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ DDL ìƒì„±ì„ 가능하ë„ë¡ í•´ì¤€ë‹¤. ë˜í•œ ì´ê²ƒì´ property-refì˜ ëŒ€ìƒì´ ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤. ì´ê²ƒì€ ì—°ê´€ 다중성(association multiplicity)ì„ íš¨ìœ¨ì 으로 ì¼ ëŒ€ ì¼ë¡œ ë§Œë“ ë‹¤."
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr "<literal>not-null</literal> (옵션): foreign key ì»¬ëŸ¼ë“¤ì„ ìœ„í•œ null 가능한 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ DDL ìƒì„±ì„ 가능하ë„ë¡ í•´ì¤€ë‹¤."
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì´ í”„ë¡œí¼í‹°ì— 대한 ì—…ë°ì´íŠ¸ë“¤ì´ optimistic lockì˜ íšë“ì„ í•„ìš”ë¡œ 하는지 아닌지 여부를 ì§€ì •í•œë‹¤. 달리 ë§í•´ ì´ í”„ë¡œí¼í‹°ê°€ dirtyì¼ ë•Œ version ì¦ê°€ê°€ ë°œìƒí•´ì•¼ í• ê²½ìš°ì¸ì§€ë¥¼ ê²°ì •í•œë‹¤."
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>proxy</literal>): ë””í´íŠ¸ë¡œ, ë‹¨ì¼ í¬ì¸íŠ¸ ì—°ê´€ë“¤ì´ í”„ë½ì‹œëœë‹¤. <literal>lazy=\"no-proxy\"</literal>는 ì¸ìŠ¤í„´ìŠ¤ 변수가 처ìŒìœ¼ë¡œ ì ‘ê·¼ë ë•Œ ê·¸ 프로í¼í‹°ê°€ lazily 페치ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤(빌드-ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 한다). <literal>lazy=\"false\"</literal>는 ê·¸ ì—°ê´€ì´ í•ìƒ eagerly 페치ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤."
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr "<literal>not-found</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>exception</literal>): 누ë½ëœ í–‰ë“¤ì„ ì°¸ì¡°í•˜ëŠ” foreign keyë“¤ì´ ì–´ë–»ê²Œ 처리ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤: <literal>ignore</literal>는 í•œ ê°œì˜ ëˆ„ë½ëœ í–‰ì„ í•œ ê°œì˜ null 연관으로 ì·¨ê¸‰í• ê²ƒì´ë‹¤."
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr "<literal>entity-name</literal> (옵션): ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ 엔티티 ì´ë¦„."
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr "<literal>formula</literal> (옵션): <emphasis>계산ëœ</emphasis> foreign keyì— ëŒ€í•œ ê°’ì„ ì •ì˜í•˜ëŠ” SQL 표현ì‹."
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr "<literal>cascade</literal> ì†ì„± ê°’ì„ <literal>none</literal> ì•„ë‹Œ ì–´ë–¤ ì˜ë¯¸ìžˆëŠ” 다른 값으로 ì„¤ì •í•˜ëŠ” ê²ƒì€ ì–´ë–¤ 오í¼ë ˆì´ì…˜ë“¤ì„ ì—°ê´€ëœ ê°ì²´ì—게 ë³´ê¸‰í• ê²ƒì´ë‹¤. ìœ ì˜ë¯¸í•œ ê°’ë“¤ì€ Hibernateì˜ ê¸°ë³¸ 오í¼ë ˆì´ì…˜ë“¤ì˜ ì´ë¦„들, 즉 <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal> ë¿ë§Œ ì•„ë‹ˆë¼ íŠ¹ë³„í•œ 값들, 즉 <literal>delete-orphan</literal>ê³¼ <literal>all</literal> ê·¸ë¦¬ê³ ì˜¤í¼ë ˆì´ì…˜ ì´ë¦„ë“¤ì˜ ì‰¼í‘œ ë¶„ë¦¬ëœ ì¡°í•©ë“¤, 예를 들면 <literal>cascade=\"persist,merge,evict\"</literal> ë˜ëŠ” <literal>cascade=\"all,delete-orphan\"</literal>ì´ë‹¤. ì „ì²´ ì„¤ëª…ì€ <xref linkend=\"objectstate-transitive\"/>를 ë³´ë¼. 단ì¼ê°’ 연관들(many-to-one 연관과 one-to-one ì—°ê´€)ì€ orphan delete를 지ì›í•˜ì§€ ì•ŠìŒì„ 노트하ë¼."
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "ì¼ë°˜ì ì¸ <literal>many-to-one</literal> ì„ ì–¸ì€ ë‹¤ìŒê³¼ ê°™ì´ ê°„ë‹¨í•˜ê²Œ 보여진다:"
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr "<literal>property-ref</literal> ì†ì„±ì€ ì˜¤ì§ foreign keyê°€ 프ë¼ì´ë¨¸ë¦¬ 키가 ì•„ë‹Œ ì—°ê´€ëœ í…Œì´ë¸”ì˜ ìœ ì¼ í‚¤ë¥¼ 참조하는 리거시 ë°ì´í„°ë¥¼ 매핑하는ë°ë§Œ 사용ëœë‹¤. ì´ê²ƒì€ 꼴사나운 관계형 모형ì´ë‹¤. 예를 들어, <literal>Product</literal> í´ëž˜ìŠ¤ê°€ 프ë¼ì´ë¨¸ë¦¬ 키를 ì•„ë‹Œ, ìœ ì¼í•œ 시리얼 번호를 ê°–ëŠ”ë‹¤ê³ ê°€ì •í•˜ìž.(<literal>unique</literal> ì†ì„±ì€ SchemaExport ë„구로 Hibernateì˜ DDL ìƒì„±ì„ ì œì–´í•œë‹¤.)"
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr "그런 ë‹¤ìŒ <literal>OrderItem</literal>ì— ëŒ€í•œ ë§¤í•‘ì€ ë‹¤ìŒì„ ì‚¬ìš©í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "하지만 ì´ê²ƒì€ 확실히 권장ë˜ì§€ 않는다."
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr "ë§Œì¼ ì°¸ì¡°ëœ ìœ ì¼ í‚¤ê°€ ì—°ê´€ëœ ì—”í‹°í‹°ì˜ ì—¬ëŸ¬ 프로í¼í‹°ë“¤ì„ í¬í•¨í• 경우, ë‹¹ì‹ ì€ ëª…ëª…ëœ <literal><properties></literal> 요소 ë‚´ë¶€ì— ì°¸ì¡°ëœ í”„ë¡œí¼í‹°ë“¤ì„ ë§¤í•‘í• ê²ƒì´ë‹¤."
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr "ë§Œì¼ ì°¸ì¡°ëœ ìœ ì¼í‚¤ê°€ ì»´í¬ë„ŒíŠ¸ì˜ 프로í¼í‹°ì¼ 경우, ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ í”„ë¡œí¼í‹° 경로를 ì§€ì •í• ìˆ˜ 있다:"
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "one-to-one"
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr "ë˜ ë‹¤ë¥¸ ì˜ì† í´ëž˜ìŠ¤ì— 대한 one-to-one 연관관계는 <literal>one-to-one</literal> 요소를 사용하여 ì„ ì–¸ëœë‹¤."
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr "<literal>name</literal>: 프로í¼í‹°ì˜ ì´ë¦„."
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr "<literal>cascade</literal> (옵션) ì–´ëŠ ì˜¤í¼ë ˆì´ì…˜ë“¤ì´ 부모 ê°ì²´ë¡œë¶€í„° ì—°ê´€ëœ ê°ì²´ë¡œ 케스케ì´ë“œ ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr "<literal>constrained</literal> (옵션) ë§¤í•‘ëœ í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ í‚¤ì— ëŒ€í•œ foreign 키 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ê°€ ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ëŠ”ì§€ 여부를 ì§€ì •í•œë‹¤. ì´ ì˜µì…˜ì€ <literal>save()</literal>와 <literal>delete()</literal>ê°€ 케스케ì´ë“œ ë˜ëŠ” ìˆœì„œì— ì˜í–¥ì„ ì£¼ê³ , ê·¸ ì—°ê´€ì´ í”„ë½ì‹œ ë 것ì¸ì§€ 여부를 ê²°ì •í•œë‹¤ (ë˜í•œ 스키마 내보내기 ë„êµ¬ì— ì˜í•´ 사용ëœë‹¤)."
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr "<literal>fetch</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>select</literal>): outer-join íŽ˜ì¹ ë˜ëŠ” 순차ì ì¸ select íŽ˜ì¹ ì¤‘ì—ì„œ ì„ íƒí•˜ë¼."
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "<literal>property-ref</literal>: (옵션) ì´ í´ëž˜ìŠ¤ì˜ 프ë¼ì´ë¨¸ë¦¬ í‚¤ì— ì—°ê²°ëœ ì—°ê´€ í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ì˜ ì´ë¦„. ë§Œì¼ ì§€ì •ë˜ì§€ ì•Šì„ ê²½ìš°, ì—°ê´€ í´ëž˜ìŠ¤ì˜ 프ë¼ì´ë¨¸ë¦¬ 키가 사용ëœë‹¤."
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼ í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr "<literal>formula</literal> (옵션): ê±°ì˜ ëª¨ë“ one to one ì—°ê´€ê´€ê³„ë“¤ì€ ì†Œìœ í•˜ëŠ” ì—”í‹°í‹°ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키로 매핑ëœë‹¤. ì´ê²ƒì´ ê·¸ 경우가 ì•„ë‹Œ 드문 경우들ì—ì„œ, ë‹¹ì‹ ì€ SQL formula ì‚¬ìš©ì— ê²°í•©ì‹œí‚¬ 몇몇 다른 컬럼, 컬럼들, ë˜ëŠ” 표현ì‹ì„ ì§€ì •í• ìˆ˜ 있다.(ì˜ˆì œëŠ” <literal>org.hibernate.test.onetooneformula</literal>를 ë³´ë¼.)"
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>proxy</literal>): ë””í´íŠ¸ë¡œ 한쪽 ë ì—°ê´€ë“¤ì´ í”„ë½ì‹œ ëœë‹¤. <literal>lazy=\"no-proxy\"</literal>는 ì¸ìŠ¤í„´ìŠ¤ 변수가 ì²˜ìŒ ì ‘ê·¼ë ë•Œ ê·¸ 프로í¼í‹°ê°€ lazily 페치ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤(빌드-ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 한다). <literal>lazy=\"false\"</literal>는 ê·¸ ì—°ê´€ë“¤ì´ í•ìƒ eagerly 페치ë ê²ƒìž„ì„ ì§€ì •í•œë‹¤. <emphasis>ë§Œì¼ <literal>constrained=\"false\"</literal>ì¸ ê²½ìš°ì—, 프ë½ì‹±ì€ ë¶ˆê°€ëŠ¥í•˜ê³ Hibernate는 ê·¸ ì—°ê´€ì„ eager 페치시킬 것ì´ë‹¤!</emphasis>"
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr "<literal>entity-name</literal> (옵션): ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ 엔티티 ì´ë¦„."
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr "one-to-one 연관관계ì—는 ë‘ ê°€ì§€ ë³€ì¢…ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr "프ë¼ì´ë¨¸ë¦¬ 키 연관관계들"
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr "ìœ ì¼ foreign 키 연관관계들"
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr "프ë¼ì´ë¨¸ë¦¬ 키 ì—°ê´€ë“¤ì€ íŠ¹ë³„í•œ í…Œì´ë¸” ì»¬ëŸ¼ì„ í•„ìš”ë¡œ 하지 않는다; ë§Œì¼ ë‘ ê°œì˜ í–‰ë“¤ì´ ê·¸ ì—°ê´€ì— ì˜í•´ 관계지워지면, ë‘ ê°œì˜ í…Œì´ë¸” í–‰ë“¤ì€ ë™ì¼í•œ 프ë¼ì´ë¨¸ë¦¬ 키 ê°’ì„ ê³µìœ í•œë‹¤. ë”°ë¼ì„œ ë§Œì¼ ë‘ ê°œì˜ ê°ì²´ë“¤ì´ 프ë¼ì´ë¨¸ë¦¬ 키 ì—°ê´€ì— ì˜í•´ 관계지워지ë„ë¡ ë‹¹ì‹ ì´ ì›í• 경우, ë‹¹ì‹ ì€ ê·¸ê²ƒë“¤ì— ë™ì¼í•œ ì‹ë³„ìž ê°’ì´ í• ë‹¹ë˜ë„ë¡ í•´ì•¼ 한다!"
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr "프ë¼ì´ë¨¸ë¦¬ 키 ì—°ê´€ì— ëŒ€í•´, ë‹¤ìŒ ë§¤í•‘ë“¤ì„ <literal>Employee</literal>와 <literal>Person</literal> ê°ê°ì— 추가하ë¼."
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr "ì´ì œ 우리는 PERSON ê³¼ EMPLOYEE í…Œì´ë¸”들ì—ì„œ 관계지워진 í–‰ë“¤ì˜ í”„ë¼ì´ë¨¸ë¦¬ í‚¤ë“¤ì´ ë™ì¼í•¨ì„ 확실히 해야 한다! 우리는 <literal>foreign</literal>ë¡œ 명명ë˜ëŠ” 특별한 Hibernate ì‹ë³„ìž ìƒì„± ë°©ë„를 사용한다:"
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr "그때 <literal>Person</literal>ì˜ ìƒˆë¡œì´ ì €ìž¥ëœ ì¸ìŠ¤í„´ìŠ¤ëŠ” ê·¸ <literal>Person</literal>ì˜ <literal>employee</literal> 프로í¼í‹°ì— 대해 ì°¸ì¡°ëœ <literal>Employee</literal> ì¸ìŠ¤í„´ìŠ¤ì™€ ë™ì¼í•œ 프ë¼ì´ë¨¸ë¦¬ 키를 í• ë‹¹ë°›ëŠ”ë‹¤."
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr "달리, <literal>Employee</literal>로부터 <literal>Person</literal>ìœ¼ë¡œì˜ ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ 가진 í•˜ë‚˜ì˜ foreign key는 다ìŒê³¼ ê°™ì´ í‘œí˜„ë 수 있다:"
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr "ê·¸ë¦¬ê³ ì´ ì—°ê´€ì€ ë‹¤ìŒì„ <literal>Person</literal> ë§¤í•‘ì— ì¶”ê°€í•¨ìœ¼ë¡œì¨ ì–‘ë°©í–¥ì´ ë 수 있다:"
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr "ë¹„ë¡ ìš°ë¦¬ê°€ 프ë¼ì´ë¨¸ë¦¬ 키들로서 ëŒ€ìš©í‚¤ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ê¶Œìž¥í–ˆì„지ë¼ë„, ë‹¹ì‹ ì€ ì—¬ì „ížˆ ëª¨ë“ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ natural í‚¤ë“¤ì„ ì‹ë³„í•˜ê³ ìž ì›í• 것ì´ë‹¤. narutal 키는 ìœ ì¼(unique)í•˜ê³ nullì´ ì•„ë‹Œ 프로í¼í‹° ë˜ëŠ” 프로í¼í‹°ë“¤ì˜ ì¡°í•©ì´ë‹¤. ê·¸ê²ƒì´ ë˜í•œ 불변하는 ê²ƒì¼ ê²½ìš°ê°€ ë” ì¢‹ë‹¤. <literal><natural-id></literal> 요소 ë‚´ë¶€ì— ìžˆëŠ” natural í‚¤ì˜ í”„ë¡œí¼í‹°ë“¤ì„ 매핑하ë¼. Hibernate는 필수ì ì¸ ìœ ì¼ í‚¤ì™€ null 허용가능한 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ì„ ìƒì„±ì‹œí‚¬ 것ì´ê³ , ë‹¹ì‹ ì˜ ë§¤í•‘ì€ ë³´ë‹¤ ìžê°€ 설명ì ì´ê²Œ ë 것ì´ë‹¤."
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr "ì´ ë§¤í•‘ì€ natural 프ë¼ì´ë¨¸ë¦¬ í‚¤ë“¤ì„ ê°€ì§„ ì—”í‹°í‹°ë“¤ì„ ìœ„í•œ ìš©ë„ë¡œ ê³ ì•ˆëœ ê²ƒì€ ì•„ë‹ˆë‹¤."
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr "component, dynamic-component"
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr "<literal><component></literal> 요소는 ìžì‹ ê°ì²´ì˜ 프로í¼í‹°ë“¤ì„ 부모 í´ëž˜ìŠ¤ì— 대한 í…Œì´ë¸”ì˜ ì»¬ëŸ¼ë“¤ë¡œ 매핑시킨다. ì»´í¬ë„ŒíŠ¸ë“¤ì€ 그것들 ìžì‹ ì˜ í”„ë¡œí¼í‹°ë“¤, ì»´í¬ë„ŒíŠ¸ë“¤, ë˜ëŠ” ì½œë ‰ì…˜ë“¤ì„ ì„ ì–¸í•œë‹¤. ì´ëž˜ \"ì»´í¬ë„ŒíŠ¸ë“¤\"ì„ ë³´ë¼."
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr "<literal>name</literal>: 프로í¼í‹°ì˜ ì´ë¦„."
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr "<literal>class</literal> (옵션 - ë””í´íŠ¸ëŠ” reflectionì— ì˜í•´ ê²°ì •ëœ í”„ë¡œí¼í‹° 타입): ì»´í¬ë„ŒíŠ¸(ìžì‹) í´ëž˜ìŠ¤ì˜ ì´ë¦„."
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr "<literal>insert</literal>: ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ SQL <literal>INSERT</literal>들 ì†ì— 나타나야 하는가?"
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr "<literal>update</literal>: ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ SQL <literal>UPDATE</literal>들 ì†ì— 나타나야 하는가?"
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì•¡ì„¸ìŠ¤í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ì¸ìŠ¤í„´ìŠ¤ 변수가 처ìŒìœ¼ë¡œ 액세스ë ë•Œ ì´ ì»´í¬ë„ŒíŠ¸ê°€ lazily(ëŠë¦¬ê²Œ) 페치ë˜ì–´ì•¼ 하는지 여부를 ì§€ì •í•œë‹¤ (빌드 ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 한다)."
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì´ ì»´í¬ë„ŒíŠ¸ì— 대한 ì—…ë°ì´íŠ¸ë“¤ì´ optimistic ìž ê¸ˆì„ íšë“하는 ê²ƒì„ í•„ìš”ë¡œ 하는지 여부를 ì§€ì •í•œë‹¤. 달리 ë§í•´ ì´ í”„ë¡œí¼í‹°ê°€ dirty ì¼ ë•Œ ë²„ì „ ì¦ê°€ê°€ ë°œìƒí• 것ì¸ì§€ 여부를 ê²°ì •í•œë‹¤."
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "<literal>unique</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ê°€ ì»´í¬ë„ŒíŠ¸ì˜ ëª¨ë“ ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì— ëŒ€í•´ 존재하는지 여부를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr "ìžì‹ <literal><property></literal> íƒœê·¸ë“¤ì€ ìžì‹ í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ë“¤ì„ í…Œì´ë¸” 컬럼들로 매핑시킨다."
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "<literal><component></literal> 요소는 ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ë¥¼ í¬í•¨í•˜ëŠ” ì—”í‹°í‹°ì— ëŒ€í•œ 참조로서 매핑시키는 <literal><parent></literal> 서브요소를 허용한다."
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr "<literal><dynamic-component></literal> 요소는 ì»´í¬ë„ŒíŠ¸ë¡œì„œ 매핑ë <literal>Map</literal>ì„ í—ˆìš©í•œë‹¤. 여기서 프로í¼í‹° ì´ë¦„ë“¤ì€ mapì˜ í‚¤ë“¤ì„ ì°¸ì¡°í•œë‹¤. <xref linkend=\"components-dynamic\"/>ì„ ë³´ë¼."
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr "properties"
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr "<literal><properties></literal> 요소는 í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ë“¤ì˜ 명명ëœ, 논리ì ê·¸ë£¹í•‘ì— ëŒ€í•œ ì •ì˜ë¥¼ 허용한다. ê·¸ êµ¬ì¡°ì— ëŒ€í•œ 가장 중요한 ì‚¬ìš©ì€ ê·¸ê²ƒì´ í”„ë¡œí¼í‹°ë“¤ì˜ ì¡°í•©ì´ <literal>property-ref</literal>ì˜ ëŒ€ìƒì´ ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤ëŠ” ì ì´ë‹¤. ë˜í•œ ê·¸ê²ƒì€ ë‹¤ì¤‘ 컬럼 ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸ëŠë¥¼ ì •ì˜í•˜ëŠ” 편리한 방법ì´ë‹¤."
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr ""
+ "<![CDATA[<properties \n"
+ " name=\"logicalName\" \n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ " \n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr "<literal>name</literal>: ê·¸ë£¹í•‘ì˜ ë…¼ë¦¬ì ì´ë¦„ - ì‹¤ì œ 프로í¼í‹° ì´ë¦„ì´ <emphasis>아니다</emphasis>."
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr "<literal>insert</literal>: ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ SQL <literal>INSERT</literal>들 ë‚´ì— ë‚˜íƒ€ë‚ ê²ƒì¸ê°€?"
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr "<literal>update</literal>: ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì´ SQL <literal>UPDATE</literal>들 ë‚´ì— ë‚˜íƒ€ë‚ ê²ƒì¸ê°€?"
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì´ë“¤ 프로í¼í‹°ë“¤ì— 대한 ì—…ë°ì´íŠ¸ë“¤ì´ optimistic ìž ê¸ˆì˜ íšë“ì„ í•„ìš”ë¡œ 하는지 여부를 ì§€ì •í•œë‹¤. 달리 ë§í•´ ì´ í”„ë¡œí¼í‹°ê°€ dirty ì¼ ë•Œ ë²„ì „ ì¦ê°€ê°€ ë°œìƒí• 것ì¸ì§€ 여부를 ê²°ì •í•œë‹¤."
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr "<literal>unique</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ê°€ ì»´í¬ë„ŒíŠ¸ì˜ ëª¨ë“ ë§¤í•‘ëœ ì»¬ëŸ¼ë“¤ì— ëŒ€í•´ 존재하는지 여부를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr "예를 들어, ë§Œì¼ ìš°ë¦¬ê°€ ë‹¤ìŒ <literal><properties></literal> ë§¤í•‘ì„ ê°€ì§ˆ 경우:"
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\" \n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr "ê·¸ ë•Œ 우리는 프ë¼ì´ë¨¸ë¦¬ 키가 ì•„ë‹Œ, <literal>Person</literal> í…Œì´ë¸”ì˜ ì´ ìœ ì¼ í‚¤ë¥¼ 참조하는 ì–´ë–¤ 리거시 ë°ì´í„° ì—°ê´€ì„ ê°€ì§ˆ 수 있다:"
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"person\" \n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr "subclass"
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr "마지막으로, 다형성 ì˜ì†ì„±ì€ 루트 ì˜ì† í´ëž˜ìŠ¤ì— 대한 ê°ê°ì˜ 서브í´ëž˜ìŠ¤ ì„ ì–¸ì„ í•„ìš”ë¡œ 한다.(권장ë˜ëŠ”) table-per-class-hierarchy(í…Œì´ë¸” 당 í´ëž˜ìŠ¤ 계층구조) 매핑 ë°©ë„ì˜ ê²½ìš°, <literal><subclass></literal> ì„ ì–¸ì´ ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr "<literal>discriminator-value</literal> (옵션 - ë””í´íŠ¸ëŠ” í´ëž˜ìŠ¤ ì´ë¦„): ê°œê°œì˜ ì„œë¸Œí´ëž˜ìŠ¤ë“¤ì„ 구분짓는 ê°’."
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr "<literal>proxy</literal> (옵션): lazy 초기화 프ë½ì‹œë“¤ì„ ì‚¬ìš©í•˜ëŠ”ë° í´ëž˜ìŠ¤ ë˜ëŠ” ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): <literal>lazy=\"false\"</literal> ì„¤ì •ì€ lazy 페ì¹ì˜ ì‚¬ìš©ì„ ë¶ˆê°€ëŠ¥í•˜ê²Œ ë§Œë“ ë‹¤."
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr "ê°ê°ì˜ 서브í´ëž˜ìŠ¤ëŠ” 그것 ìžì‹ ì˜ ì˜ì† 프로í¼í‹°ë“¤ê³¼ 서브í´ëž˜ìŠ¤ë“¤ì„ ì„ ì–¸í• ê²ƒì´ë‹¤. <literal><version></literal> 프로í¼í‹°ì™€ <literal><id></literal> 프로í¼í‹°ëŠ” 루트 í´ëž˜ìŠ¤ë¡œë¶€í„° ìƒì†ëœë‹¤ê³ ê°€ì •ëœë‹¤. 계층구조 ë‚´ì—ì„œ ê°ê°ì˜ 서브í´ëž˜ìŠ¤ëŠ” ìœ ì¼í•œ <literal>discriminator-value</literal>를 ì •ì˜í•´ì•¼ 한다. noneì´ ì§€ì •ë 경우, ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ ìžë°” í´ëž˜ìŠ¤ ì´ë¦„ì´ ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "ìƒì† ë§¤í•‘ë“¤ì— ëŒ€í•œ ì •ë³´ëŠ” <xref linkend=\"inheritance\"/>ì„ ë³´ë¼."
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr "joined-subclass"
+
+#: index.docbook:1928
+msgid "properties"
+msgstr "다른 방법으로 ê°ê°ì˜ 서브í´ëž˜ìŠ¤ëŠ” 그것 ìžì‹ ì´ í…Œì´ë¸”ë¡œ 매핑ë 수 있다(table-per-subclass 매핑 ë°©ë„). ìƒì†ëœ ìƒíƒœëŠ” 슈í¼í´ëž˜ìŠ¤ì˜ í…Œì´ë¸”ê³¼ ì¡°ì¸í•¨ìœ¼ë¡œì¨ 검색ëœë‹¤. 우리는 <literal><joined-subclass></literal> 요소를 사용한다."
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr "<literal>name</literal>: 서브í´ëž˜ìŠ¤ì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ í´ëž˜ìŠ¤ 명."
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr "<literal>table</literal>: 서브í´ëž˜ìŠ¤ í…Œì´ë¸”ì˜ ì´ë¦„."
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr "íŒë³„ìž(discriminator) ì»¬ëŸ¼ì€ ì´ ë§¤í•‘ ë°©ë„ì— í•„ìš”í•˜ì§€ 않다. 하지만 ê°ê°ì˜ 서브í´ëž˜ìŠ¤ëŠ” <literal><key></literal> 요소를 사용하여 ê°ì²´ ì‹ë³„ìžë¥¼ 보관하는 í…Œì´ë¸” ì»¬ëŸ¼ì„ ì„ ì–¸í•´ì•¼ 한다. ì´ ìž¥ì˜ ì‹œìž‘ ë¶€ë¶„ì— ìžˆëŠ” ë§¤í•‘ì€ ë‹¤ìŒê³¼ ê°™ì´ ë‹¤ì‹œ 작성ë 것ì´ë‹¤:"
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr "ìƒì† ë§¤í•‘ë“¤ì— ëŒ€í•œ ì •ë³´ëŠ” <xref linkend=\"inheritance\"/>ì„ ë³´ë¼."
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr "union-subclass"
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "ì œ3ì˜ ì˜µì…˜ì€ ìƒì† ê³„ì¸µêµ¬ì¡°ì˜ concrete í´ëž˜ìŠ¤ë“¤ ë§Œì„ í…Œì´ë¸”들로 매핑하는 것ì´ë‹¤ (table-per-concrete-class ë°©ë„). 여기서 ê°ê°ì˜ í…Œì´ë¸”ì€ ìƒì†ëœ ìƒíƒœë¥¼ í¬í•¨í•˜ì—¬ í´ëž˜ìŠ¤ì˜ ëª¨ë“ ì˜ì† ìƒíƒœë¥¼ ì •ì˜í•œë‹¤. Hibernateì—ì„œ, ê·¸ê²ƒì€ ê·¸ëŸ° ìƒì† ê³„ì¸µêµ¬ì¡°ë“¤ì„ ëª…ì‹œì 으로 ë§¤í•‘í•˜ëŠ”ë° í•„ìˆ˜ì ì´ì§€ 않다. ë‹¹ì‹ ì€ ë³„ë„ì˜ <literal><class></literal> ì„ ì–¸ì„ ê°€ì§„ ê°ê°ì˜ í´ëž˜ìŠ¤ë¥¼ 간단히 매핑시킬 수 있다. 하지만 ë‹¹ì‹ ì´ ë‹¤í˜•ì„± 연관관계들(예를 들면 ë‹¹ì‹ ì˜ ê³„ì¸µêµ¬ì¡°ì˜ ìŠˆí¼í´ëž˜ìŠ¤ì— 대한 ì—°ê´€)ì„ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ <literal><union-subclass></literal> ë§¤í•‘ì„ ì‚¬ìš©í• í•„ìš”ê°€ 있다."
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr "<literal>name</literal>: 서브í´ëž˜ìŠ¤ì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ í´ëž˜ìŠ¤ 명."
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr "<literal>table</literal>: 서브í´ëž˜ìŠ¤ í…Œì´ë¸”ì˜ ì´ë¦„."
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr "<literal>proxy</literal> (옵션): 프ë½ì‹œë“¤ì„ lazy 초기화 ì‹œí‚¤ëŠ”ë° ì‚¬ìš©í• í´ëž˜ìŠ¤ ë˜ëŠ” ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ ì§€ì •í•œë‹¤."
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): <literal>lazy=\"false\"</literal> ì„¤ì •ì€ lazy 페ì¹ì„ 사용불가능하게 ë§Œë“ ë‹¤."
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr "ì´ ë§¤í•‘ ë°©ë„ì—는 íŒë³„ìž ì»¬ëŸ¼ì´ë‚˜ 키 ì»¬ëŸ¼ì´ í•„ìš”í•˜ì§€ 않다."
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr "ìƒì† ë§¤í•‘ë“¤ì— ëŒ€í•œ ì •ë³´ëŠ” <xref linkend=\"inheritance\"/>ì„ ë³´ë¼."
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr "join"
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal><join></literal>요소를 사용하면, í…Œì´ë¸”들 사ì´ì— 1ëŒ€ì¼ ê´€ê³„ê°€ ì¡´ìž¬í• ë•Œ, í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ì— ì†í•œ 프로í¼í‹°ë“¤ì„ 여러 í…Œì´ë¸”들로 매핑시키는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ " \n"
+ " <key ... />\n"
+ " \n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr "<literal>table</literal>: ì¡°ì¸ëœ í…Œì´ë¸”ì˜ ì´ë¦„."
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr "<literal>schema</literal> (옵션): 루트 <literal><hibernate-mapping></literal> ìš”ì†Œì— ì˜í•´ ì§€ì •ëœ ìŠ¤í‚¤ë§ˆ ì´ë¦„ì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다"
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr "<literal>catalog</literal> (옵션): 루트 <literal><hibernate-mapping></literal> ìš”ì†Œì— ì˜í•´ ì§€ì •ëœ ì¹´íƒ€ë¡ ì´ë¦„ì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다."
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr "<literal>fetch</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>join</literal>): <literal>join</literal>으로 ì„¤ì •ë 경우, ë””í´íŠ¸ë¡œ Hibernate는 í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ ë˜ëŠ” ê·¸ê²ƒì˜ ìŠˆí¼ í´ëž˜ìŠ¤ë“¤ì— ì˜í•´ ì •ì˜ëœ <literal><join></literal>ì„ ê²€ìƒ‰í•˜ëŠ”ë° inner joinì„ ì‚¬ìš©í•˜ê³ ì„œë¸Œí´ëž˜ìŠ¤ì— ì˜í•´ ì •ì˜ëœ <literal><join></literal>ì„ ê²€ìƒ‰í•˜ëŠ”ë° outer joinì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. ë§Œì¼ <literal>select</literal>ë¡œ ì„¤ì •í• ê²½ìš°, Hibernate는 서브í´ëž˜ìŠ¤ ìƒì— ì •ì˜ëœ <literal><join></literal>ì— ëŒ€í•´ sequential select를 ì‚¬ìš©í• ê²ƒì´ê³ , ê·¸ê²ƒì€ í•œ í–‰ì´ ì„œë¸Œí´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 표현하는 것으로 íŒëª…ë˜ëŠ” 경우ì—만 ëª…ë ¹ì´ ë‚´ë ¤ì§ˆ 것ì´ë‹¤. inner joinë“¤ì€ ì—¬ì „ížˆ í´ëž˜ìŠ¤ì™€ ê·¸ê²ƒì˜ ìŠˆí¼í´ëž˜ìŠ¤ë“¤ì— ì˜í•´ ì •ì˜ëœ <literal><join></literal>ì„ ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©ë 것ì´ë‹¤."
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr "<literal>optional</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>): ì´ìš© ê°€ëŠ¥í• ê²½ìš°, Hibernate는 ì´ ì¡°ì¸ì— ì˜í•´ ì •ì˜ëœ 프로í¼í‹°ë“¤ì´ nullì´ ì•„ë‹ ê²½ìš°ì—만 í•œ í–‰ì„ ì‚½ìž…ì‹œí‚¬ 것ì´ê³ ê·¸ 프로í¼í‹°ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° outer joinì„ í•ìƒ ì‚¬ìš©í• ê²ƒì´ë‹¤."
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr "ì´ íŠ¹ì§•ì€ ìžì£¼ 리거시 ë°ì´í„° ëª¨í˜•ë“¤ì— ëŒ€í•´ì„œë§Œ ìœ ìš©í•˜ê³ , 우리는 í´ëž˜ìŠ¤ë“¤ê³¼ 잘 ì •ì œëœ ë„ë©”ì¸ ëª¨í˜• 보다 ë” ì ì€ í…Œì´ë¸”ë“¤ì„ ê¶Œìž¥í•œë‹¤. 하지만 ë’· ë¶€ë¶„ì— ì„¤ëª…ë˜ì–´ 있듯ì´, ê·¸ê²ƒì€ í•˜ë‚˜ì˜ ê³„ì¸µêµ¬ì¡° ë‚´ì— ìžˆëŠ” ìƒì† 매핑 ë°©ë„들 사ì´ë¥¼ ì „í™˜í•˜ëŠ” ê²ƒì— ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr "<title>key</title>"
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr "<literal>column</literal> (옵션): foreign key ì»¬ëŸ¼ì˜ ì´ë¦„. ì´ê²ƒì€ ë˜í•œ ë‚´í¬ëœ <literal><column></literal> 요소(들)ì— ì˜í•´ ì§€ì •ë 수 있다."
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr "<literal>on-delete</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>noaction</literal>): foreign key ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ê°€ ë°ì´í„°ë² ì´ìŠ¤ ë ˆë²¨ì˜ cascade delete를 사용가능하ë„ë¡ í• ê²ƒì¸ì§€ 여부를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr "우리는 delete í¼í¬ë¨¼ìŠ¤ê°€ 중요한 ì‹œìŠ¤í…œë“¤ì— ëŒ€í•´ ê¶Œìž¥í•˜ê³ , ëª¨ë“ í‚¤ë“¤ì€ <literal>on-delete=\"cascade\"</literal>ë¡œ ì •ì˜ë˜ê³ , Hibernate는 ë§Žì€ <literal>DELETE</literal> 문장들 ëŒ€ì‹ ì—, ë°ì´í„°ë² ì´ìŠ¤ ë ˆë²¨ì˜ <literal>ON CASCADE DELETE</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ì‚¬ìš©í• ê²ƒì´ë‹¤. ì´ íŠ¹ì§•ì€ Hibernateì˜ í†µìƒì ì¸ ë²„ì „í™”ëœ ë°ì´í„°ì— 대한 optimistic ìž ê¸ˆ ë°©ë„를 무시한다는 ì ì„ ì•Œê³ ìžˆì–´ë¼."
+
+#: index.docbook:2179
+msgid "join"
+msgstr "column 요소와 formula 요소"
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr "column ì†ì„±ì„ 허용하는 ìž„ì˜ì˜ 매핑 요소는 대안ì 으로 í•˜ë‚˜ì˜ <literal><column></literal> 서브요소를 ìˆ˜ìš©í• ê²ƒì´ë‹¤. 비슷하게 <literal><formula></literal>는 <literal>formula</literal> ì†ì„±ì— 대한 대안ì´ë‹¤."
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr "<![CDATA[<formula>SQL expression</formula>]]>"
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr "import"
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr "ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ë™ì¼í•œ ì´ë¦„ì„ ê°€ì§„ ë‘ ê°œì˜ ì˜ì† í´ëž˜ìŠ¤ë“¤ì„ ê°–ê³ , ë‹¹ì‹ ì´ Hibernate 질ì˜ë“¤ ë‚´ì—ì„œ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ (패키지)ì´ë¦„ì„ ì§€ì •í•˜ëŠ” ê²ƒì„ ì›í•˜ì§€ ì•ŠëŠ”ë‹¤ê³ ê°€ì •í•˜ìž. í´ëž˜ìŠ¤ë“¤ì€ <literal>auto-import=\"true\"</literal>ì— ì˜ì¡´í•˜ê¸° 보다 명시ì 으로 \"ìž„í¬íŠ¸ ë \" 것ì´ë‹¤. ë‹¹ì‹ ì€ ì‹¬ì§€ì–´ 명시ì 으로 매핑ë˜ì§€ 않는 í´ëž˜ìŠ¤ë“¤ê³¼ ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì„ ìž„í¬íŠ¸ 시킬 수(ê°€ì ¸ì˜¤ê¸° í• ìˆ˜) 있다."
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr "<literal>class</literal>: ìž„ì˜ì˜ Java í´ëž˜ìŠ¤ì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ í´ëž˜ìŠ¤ ì´ë¦„."
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "<literal>rename</literal> (옵션 - ë””í´íŠ¸ëŠ” 수ì‹ì–´ê°€ 붙지 ì•Šì€ í´ëž˜ìŠ¤ ì´ë¦„): ì§ˆì˜ ì–¸ì–´ ë‚´ì—ì„œ 사용ë ì´ë¦„."
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr "<title>any</title>"
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr "하나 ì´ìƒì˜ 프로í¼í‹° 매핑 íƒ€ìž…ì´ ì¡´ìž¬í•œë‹¤. <literal><any></literal> 매핑 요소는 여러 í…Œì´ë¸”들로부터 í´ëž˜ìŠ¤ë“¤ì— 대한 í•˜ë‚˜ì˜ ë‹¤í˜•ì„± 연관관계를 ì •ì˜í•œë‹¤. ì´ ë§¤í•‘ íƒ€ìž…ì€ ì–¸ì œë‚˜ 하나 ì´ìƒì˜ ì»¬ëŸ¼ì„ í•„ìš”ë¡œ 한다. 첫 번째 ì»¬ëŸ¼ì€ ì—°ê´€ëœ ì—”í‹°í‹°ì˜ íƒ€ìž…ì„ ë³´ê´€í•œë‹¤. 나머지 ì»¬ëŸ¼ë“¤ì€ ì‹ë³„ìžë¥¼ 보관한다. ì´ëŸ° ì¢…ë¥˜ì˜ ì—°ê´€ê´€ê³„ë“¤ì— ëŒ€í•´ foreign key ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ì§€ì •í•˜ëŠ” ê²ƒì´ ë¶ˆê°€ëŠ¥í•´ì„œ, ì´ê²ƒì€ (다형성) ì—°ê´€ê´€ê³„ë“¤ì„ ë§¤í•‘í•˜ëŠ” 통ìƒì ì¸ ë°©ë²•ìœ¼ë¡œì„œ 가장 확실한 ìˆ˜ë‹¨ì´ ì•„ë‹ˆë‹¤. ë‹¹ì‹ ì€ ë§¤ìš° 특별한 경우들 (예를 들어 ê°ì‚¬ 로그들, ì‚¬ìš©ìž ì„¸ì…˜ ë°ì´í„° 등)ì—서만 ì´ê²ƒì„ 사용해야 한다."
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr "<literal>meta-type</literal> ì†ì„±ì€ 어플리케ì´ì…˜ìœ¼ë¡œ 하여금 ë°ì´í„°ë² ì´ìŠ¤ 컬럼 ê°’ë“¤ì„ <literal>id-type</literal>ì— ì˜í•´ ì§€ì •ëœ íƒ€ìž…ì˜ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ 가진 ì˜ì† í´ëž˜ìŠ¤ë“¤ë¡œ 매핑시키는 맞춤형 íƒ€ìž…ì„ ì§€ì •í•˜ë„ë¡ í•œë‹¤. ë‹¹ì‹ ì€ meta-typeì˜ ê°’ë“¤ë¡œë¶€í„° í´ëž˜ìŠ¤ ì´ë¦„ë“¤ë¡œì˜ ë§¤í•‘ì„ ì§€ì •í•´ì•¼ 한다."
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr "<literal>name</literal>: 프로í¼í‹° ì´ë¦„."
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "<literal>id-type</literal>: ì‹ë³„ìž íƒ€ìž…."
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr "<literal>meta-type</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>string</literal>): discriminator ë§¤í•‘ì— í—ˆìš©ë˜ëŠ” ìž„ì˜ì˜ 타입."
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): cascade 스타ì¼."
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì´ í”„ë¡œí¼í‹°ì— 대한 ì—…ë°ì´íŠ¸ë“¤ì´ optimistic ìž ê¸ˆ íšë“ì„ í•„ìš”ë¡œ 하는지 여부를 ì§€ì •í•œë‹¤. 달리 ë§í•´, ì´ í”„ë¡œí¼í‹°ê°€ dirtyì¼ ê²½ìš°ì— ë²„ì „ì¦ê°€ê°€ ë°œìƒí• 것ì¸ì§€ 여부를 ì •ì˜í•œë‹¤."
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr "Hibernate 타입들"
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr "엔티티들과 값들"
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr "ì˜ì† ì„œë¹„ìŠ¤ì— ê´€í•œ 여러 Java 언어-ë ˆë²¨ì˜ ê°ì²´ë“¤ì„ ì´í•´í•˜ê¸° 위해, 우리는 ê·¸ê²ƒë“¤ì„ ë‹¤ìŒ ë‘ ê°œì˜ ê·¸ë£¹ë“¤ë¡œ ë¶„ë¥˜í• í•„ìš”ê°€ 있다:"
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr "<emphasis>entity</emphasis>는 ì—”í‹°í‹°ì— ëŒ€í•œ ì°¸ì¡°ë“¤ì„ ë³´ê´€í•˜ëŠ” ìž„ì˜ì˜ 다른 ê°ì²´ë“¤ê³¼ëŠ” ë…립ì 으로 존재한다. 참조ë˜ì§€ ì•Šì€ ê°ì²´ê°€ ì“°ë ˆê¸° 수집ë˜ëŠ” 통ìƒì˜ ìžë°” 모형과 ì´ê²ƒì€ 대조ì ì´ë‹¤. (ì €ìž¥ë“¤ê³¼ ì‚ì œë“¤ì´ ë¶€ëª¨ 엔티티로부터 ê·¸ê²ƒì˜ ìžì‹ìœ¼ë¡œì˜ 케스케ì´ë“œ ë˜ëŠ” 경우를 ì œì™¸í•˜ë©´) ì—”í‹°í‹°ë“¤ì€ ëª…ì‹œì 으로 ì €ìž¥ë˜ê³ ì‚ì œë˜ì–´ì•¼ 한다. ì´ê²ƒì€ ë„달 가능성(reachablity)ì— ì˜í•œ ê°ì²´ ì˜ì†ì„±ì˜ ODMG 모형과는 다르다 - ê·¸ë¦¬ê³ ì–´í”Œë¦¬ì¼€ì´ì…˜ ê°ì²´ë“¤ì´ 대형 시스템들ì—ì„œ 대개 어떻게 사용ë˜ëŠ”ê°€ì— í›¨ì”¬ ë” ê°€ê¹ê²Œ 대ì‘한다. ì—”í‹°í‹°ë“¤ì€ ìˆœí™˜ 참조와 ê³µìœ ì°¸ì¡°ë“¤ì„ ì§€ì›í•œë‹¤. 그것들 ë˜í•œ ë²„ì „í™” ë 수 있다."
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "ì—”í‹°í‹°ì˜ ì˜ì† ìƒíƒœëŠ” 다른 ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ 참조들과 <emphasis>value</emphasis> 타입들로 구성ëœë‹¤. ê°’ë“¤ì€ ì›ì‹œ 타입들, ì½œë ‰ì…˜ë“¤(í•˜ë‚˜ì˜ ì½œë ‰ì…˜ ë‚´ë¶€ì— ìžˆì§€ 않는 것들), ì»´í¬ë„ŒíŠ¸ë“¤, ê·¸ë¦¬ê³ ì–´ë–¤ ë¶ˆë³€ì˜ ê°ì²´ë“¤ì´ë‹¤. entities와는 달리, (특별한 ì½œë ‰ì…˜ë“¤ê³¼ ì»´í¬ë„ŒíŠ¸ë“¤ì—ì„œ) ê°’ë“¤ì€ ë„달가능성(reachability)ì— ì˜í•´ ì˜ì†í™” <emphasis>ë˜ê³ </emphasis> ì‚ì œ ëœë‹¤. value ê°ì²´ë“¤(ê³¼ ì›ì‹œ 타입들)ì´ ê·¸ê²ƒë“¤ì˜ í¬í•¨í•˜ëŠ” ì—”í‹°í‹°ì— ë”°ë¼ ì˜ì†í™” ë˜ê³ ì‚ì œ ë˜ë¯€ë¡œ, ê·¸ê²ƒë“¤ì€ ë…립ì 으로 ë²„ì „í™” ë˜ì§€ 않는다. ê°’ë“¤ì€ ë…립ì ì¸ ì—”í‹°í‹°ë¥¼ 갖지 ì•Šì•„ì„œ, ê·¸ê²ƒë“¤ì€ ë‘ ê°œì˜ ì—”í‹°í‹°ë“¤ì´ë‚˜ ì½œë ‰ì…˜ë“¤ì— ì˜í•´ ê³µìœ ë 수 없다."
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr "지금까지 우리는 ì—”í‹°í‹°ë“¤ì„ ì°¸ì¡°í•˜ê¸° 위해 \"ì˜ì† í´ëž˜ìŠ¤\"를 사용해 왔다. 우리는 ê·¸ê²ƒì„ ê³„ì† ì‚¬ìš©í• ê²ƒì´ë‹¤. 하지만 엄격히 ë§í•´, ì˜ì† ìƒíƒœë¥¼ 가진 ëª¨ë“ ì‚¬ìš©ìž ì •ì˜ í´ëž˜ìŠ¤ë“¤ì€ ì—”í‹°í‹°ë“¤ì´ ì•„ë‹ˆë‹¤. <emphasis>ì»´í¬ë„ŒíŠ¸</emphasis>는 value ì˜ë¯¸ë¥¼ 가진 ì‚¬ìš©ìž ì •ì˜ í´ëž˜ìŠ¤ì´ë‹¤. <literal>java.lang.String</literal> íƒ€ìž…ì˜ ìžë°” 프로í¼í‹°ëŠ” ë˜í•œ value ì˜ë¯¸ë¥¼ 갖는다. ì´ ì •ì˜ê°€ 주어지면, 우리는 JDKì— ì˜í•´ ì œê³µëœ ëª¨ë“ íƒ€ìž…ë“¤(í´ëž˜ìŠ¤ë“¤)ì´ ìžë°”ì—ì„œ value 타입 ì˜ë¯¸ë¥¼ ê°–ê³ , ë°˜ë©´ì— ì‚¬ìš©ìž ì •ì˜ íƒ€ìž…ë“¤ì€ ì—”í‹°í‹° ë˜ëŠ” type ì˜ë¯¸ë¡œì„œ 매핑ëœë‹¤ê³ ë§í• 수 있다. ì´ íŒë‹¨ì€ 어플리케ì´ì…˜ 개발ìžì—게 ë‹¬ë ¤ 있다. ë„ë©”ì¸ ëª¨í˜•ì—ì„œ 엔티티 í´ëž˜ìŠ¤ì— 대한 ì¢‹ì€ ížŒíŠ¸ëŠ” ê·¸ í´ëž˜ìŠ¤ì˜ í•˜ë‚˜ì˜ ì¸ìŠ¤í„´ìŠ¤ì— 대한 ê³µìœ ëœ ì°¸ì¡°ë“¤ì¸ ë°˜ë©´ì—, compositionì´ë‚˜ aggregationì€ ëŒ€ê°œ value í!
ƒ€ìž…으로 변환ëœë‹¤."
+
+#: index.docbook:2367
+msgid "import"
+msgstr "우리는 문서를 통해 ë‘ ê°œë…ë“¤ì„ ë‹¤ì‹œ ê³ ì°°í• ê²ƒì´ë‹¤."
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr "ë„ì ì ì€ Java type 시스템(ê³¼ 엔티티들 ë° value íƒ€ìž…ë“¤ì— ëŒ€í•œ 개발ìžì˜ ì •ì˜)를 SQL/ë°ì´í„°ë² ì´ìŠ¤ type 타입으로 매핑하는 것ì´ë‹¤. ë‘ ì‹œìŠ¤í…œë“¤ 사ì´ì˜ 다리는 Hibernateì— ì˜í•´ ì œê³µëœë‹¤: ì—”í‹°í‹°ë“¤ì˜ ê²½ìš° 우리는 <literal><class></literal>, <literal><subclass></literal> ë“±ì„ ì‚¬ìš©í•œë‹¤.value íƒ€ìž…ë“¤ì˜ ê²½ìš° 우리는 대개<literal>type</literal> ì†ì„±ì„ 가진 <literal><property></literal>, <literal><component></literal> ë“±ì„ ì‚¬ìš©í•œë‹¤. ì´ ì†ì„±ì˜ ê°’ì€ Hibernate <emphasis>매핑 타입</emphasis>ì˜ ì´ë¦„ì´ë‹¤. Hibernate는 (표준 JDK value íƒ€ìž…ë“¤ì— ëŒ€í•´) ë§Žì€ ë§¤í•‘ë“¤ì„ ì œê³µí•œë‹¤. ë‚˜ì¤‘ì— ë³´ê²Œ ë˜ë“¯ì´, ë‹¹ì‹ ì€ ë‹¹ì‹ ìžì‹ ì˜ ë§¤í•‘ íƒ€ìž…ë“¤ì„ ìž‘ì„±í• ìˆ˜ ìžˆê³ ë§ˆì°¬ê°€ì§€ë¡œ ë‹¹ì‹ ì˜ ë§žì¶¤í˜• 변환 ë°©ë„ë“¤ì„ êµ¬í˜„í• ìˆ˜ 있다."
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr "ì½œë ‰ì…˜ë“¤ì„ ì œì™¸í•œ ëª¨ë“ ë¯¸ë¦¬ ë¹Œë“œëœ Hibernate íƒ€ìž…ë“¤ì€ null ì˜ë¯¸ë¥¼ 지ì›í•œë‹¤."
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr "기본 value 타입들"
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr "미리-만들어진 <emphasis>기본 매핑 타입들</emphasis>ì€ ëŒ€ëžµ 다ìŒê³¼ ê°™ì´ ì¹´í…Œê³ ë¦¬ë¡œ 분류ëœë‹¤"
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr "ìžë°” ì›ì‹œíƒ€ìž…들ì´ë‚˜ wrapper í´ëž˜ìŠ¤ë“¤ë¡œë¶€í„° ì ì ˆí•œ(벤ë”-ì§€ì •ì ì¸) SQL 컬럼 íƒ€ìž…ë“¤ë¡œì˜ íƒ€ìž… 매핑. <literal>boolean, yes_no</literal>와 <literal>true_false</literal>는 Java <literal>boolean</literal>ì´ë‚˜ <literal>java.lang.Boolean</literal>ì— ëŒ€í•œ ëª¨ë“ ëŒ€ì²´ì ì¸ ì¸ì½”딩들ì´ë‹¤."
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr "string"
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "<literal>java.lang.String</literal>으로부터 <literal>VARCHAR</literal> (ë˜ëŠ” Oracle <literal>VARCHAR2</literal>)ë¡œì˜ íƒ€ìž… 매핑."
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr "date, time, timestamp"
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr "<literal>java.util.Date</literal>와 ê·¸ê²ƒì˜ ì„œë¸Œí´ëž˜ìŠ¤ë¡œë¶€í„° SQL íƒ€ìž…ë“¤ì¸ <literal>DATE</literal>, <literal>TIME</literal>, <literal>TIMESTAMP</literal> (ë˜ëŠ” 등가물)ë¡œì˜ íƒ€ìž… 매핑들."
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr "calendar, calendar_date"
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr "<literal>java.util.Calendar</literal>로부터 SQL íƒ€ìž…ë“¤ì¸ <literal>TIMESTAMP</literal>, <literal>DATE</literal> (ë˜ëŠ” 등가물)ë¡œì˜ íƒ€ìž… 매핑들."
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr "big_decimal, big_integer"
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "<literal>java.math.BigDecimal</literal>ê³¼ <literal>java.math.BigInteger</literal>로부터 <literal>NUMERIC</literal> (ë˜ëŠ” Oracle <literal>NUMBER</literal>)ë¡œì˜ íƒ€ìž… 매핑들."
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr "<literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal>, ê·¸ë¦¬ê³ <literal>java.util.Currency</literal>로부터 <literal>VARCHAR</literal>(ë˜ëŠ” Oracle <literal>VARCHAR2</literal>)ë¡œì˜ íƒ€ìž… 매핑. <literal>Locale</literal>ê³¼ <literal>Currency</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ê·¸ê²ƒë“¤ì˜ ISO 코드들로 매핑ëœë‹¤. <literal>TimeZone</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ê·¸ê²ƒë“¤ì˜ <literal>ID</literal>ë¡œ 매핑ëœë‹¤."
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr "<literal>class</literal>"
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr "<literal>java.lang.Class</literal>로부터 <literal>VARCHAR</literal> (ë˜ëŠ” Oracle <literal>VARCHAR2</literal>)ë¡œì˜ íƒ€ìž… 매핑. <literal>Class</literal>는 ê·¸ê²ƒì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ ì´ë¦„으로 매핑ëœë‹¤."
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr "binary"
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr "byte ë°°ì—´ë“¤ì„ ì ì ˆí•œ SQL binary 타입으로 매핑시킨다."
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "text"
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr "long Java 문ìžì—´ì„ SQL <literal>CLOB</literal> ë˜ëŠ” <literal>TEXT</literal> 타입으로 매핑시킨다"
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr "serializable"
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr "serializable Java íƒ€ìž…ë“¤ì„ ì ì ˆí•œ SQL binary 타입으로 매핑시킨다. ë‹¹ì‹ ì€ ë˜í•œ ë””í´íŠ¸ë¡œ 기본 íƒ€ìž…ì´ ì•„ë‹Œ serializable ìžë°” í´ëž˜ìŠ¤ ë˜ëŠ” ì¸í„°íŽ˜ì´ìŠ¤ì˜ ì´ë¦„ì„ ê°€ì§„ Hibernate 타입 <literal>serializable</literal>ì„ ë‚˜íƒ€ë‚¼ ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr "clob, blob"
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr "<literal>java.sql.Clob</literal>와 <literal>java.sql.Blob</literal> JDBC í´ëž˜ìŠ¤ë“¤ì— 대한 타입 매핑들. ì´ë“¤ íƒ€ìž…ë“¤ì€ ëª‡ëª‡ 어플리케ì´ì…˜ë“¤ì—서는 불편하다. 왜ëƒí•˜ë©´ blob ë˜ëŠ” clob ê°ì²´ëŠ” 트랜ìžì…˜ 외부ì—ì„œ 재사용ë 수 없기 때문ì´ë‹¤.(게다가 ë“œë¼ì´ë²„ 지ì›ì´ 비ì¼ê´€ì ì´ê³ 페치ë˜ì–´ì•¼ 한다)"
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr "대개 가변ì ì¸ Java 타입들로 간주ë˜ëŠ” ê²ƒì— ëŒ€í•œ 타입 매핑들. 여기서 Hibernate는 불변ì ì¸ Java íƒ€ìž…ë“¤ì— ëŒ€í•´ì„œë§Œ ì ì ˆí•œ ì–´ë–¤ 최ì 화를 í–‰í•˜ê³ , 어플리케ì´ì…˜ ê·¸ ê°ì²´ë¥¼ ë³€í• ìˆ˜ 없는 것으로 취급한다. 예를 들어, ë‹¹ì‹ ì€ <literal>imm_timestamp</literal>로서 ë§¤í•‘ëœ ì¸ìŠ¤í„´ìŠ¤ì— 대해 <literal>Date.setTime()</literal>ì„ í˜¸ì¶œí•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. 프로í¼í‹°ì˜ ê°’ì„ ë³€ê²½ì‹œí‚¤ê³ , ê·¸ ë³€ê²½ì„ ì˜ì†í™” 시키기 위해서, 어플리케ì´ì…˜ì€ í•˜ë‚˜ì˜ ìƒˆë¡œìš´ (ë™ì¼í•˜ì§€ ì•Šì€) ê°ì²´ë¥¼ ê·¸ 프로í¼í‹°ì— í• ë‹¹í•´ì•¼ 한다."
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "엔트리들과 ì½œë ‰ì…˜ë“¤ì˜ ìœ ì¼ ì‹ë³„ìžë“¤ì€ <literal>binary</literal>, <literal>blob</literal> ê·¸ë¦¬ê³ <literal>clob</literal>를 ì œì™¸í•œ 기본 타입 중 ì–´ëŠ ê²ƒì¼ ìˆ˜ 있다. (Composite ì‹ë³„ìžë“¤ì´ ë˜í•œ 허용ëœë‹¤. 아래를 ë³´ë¼.)"
+
+#: index.docbook:2567
+msgid "string"
+msgstr "기본 value íƒ€ìž…ë“¤ì€ <literal>org.hibernate.Hibernate</literal>ì— ì •ì˜ë˜ì–´ 있는 대ì‘하는 <literal>Type</literal> ìƒìˆ˜ë“¤ì„ 갖는다. 예를 들어, <literal>Hibernate.STRING</literal>ì€ <literal>string</literal> íƒ€ìž…ì„ í‘œí˜„í•œë‹¤."
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr "맞춤형 value 타입들"
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr "개발ìžë“¤ì´ 그들 ìžì‹ ë“¤ì˜ value íƒ€ìž…ë“¤ì„ ìƒì„±ì‹œí‚¤ëŠ” ê²ƒì´ ìƒëŒ€ì 으로 쉽다. 예를 들어, ë‹¹ì‹ ì€ <literal>java.lang.BigInteger</literal> íƒ€ìž…ì˜ í”„ë¡œí¼í‹°ë“¤ì„ <literal>VARCHAR</literal> 컬럼들로 ì˜ì†í™” ì‹œí‚¤ê³ ìž ì›í• 수 있다. Hibernate는 ì´ê²ƒì„ 위한 미리 만들어진 íƒ€ìž…ì„ ì œê³µí•˜ì§€ 않는다. 그러나 맞춤형 íƒ€ìž…ë“¤ì€ í”„ë¡œí¼í‹°(ë˜ëŠ” ì½œë ‰ì…˜ 요소)를 í•˜ë‚˜ì˜ í…Œì´ë¸” ì»¬ëŸ¼ìœ¼ë¡œì˜ ë§¤í•‘í•˜ëŠ” ê²ƒì— ì œì•½ë˜ì§€ 않는다. ë”°ë¼ì„œ 예를 들어, ë‹¹ì‹ ì€ <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal> 컬럼들로 ì˜ì†í™” ë˜ëŠ” <literal>java.lang.String</literal> íƒ€ìž…ì˜ ìžë°” 프로í¼í‹°<literal>getName()</literal>/ <literal>setName()</literal>를 가질 수 있다."
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr "맞춤형 íƒ€ìž…ì„ êµ¬í˜„í•˜ë ¤ë©´, <literal>org.hibernate.UserType</literal> ë˜ëŠ” <literal>org.hibernate.CompositeUserType</literal>ì„ êµ¬í˜„í•˜ê³ ê·¸ íƒ€ìž…ì˜ ì „ì²´ 수ì‹ì–´ê°€ ë¶™ì€ í´ëž˜ìŠ¤ëª…ì„ ì‚¬ìš©í•˜ì—¬ 프로í¼í‹°ë“¤ì„ ì„ ì–¸í•˜ë¼. 가능한 ì¢…ë¥˜ì˜ ê²ƒë“¤ì„ ë³´ë ¤ë©´ <literal>org.hibernate.test.DoubleStringType</literal>ì„ ì²´í¬í•˜ë¼."
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "í•˜ë‚˜ì˜ í”„ë¡œí¼í‹°ë¥¼ 여러 ê°œì˜ ì»¬ëŸ¼ë“¤ë¡œ 매핑시키는 <literal><column></literal> íƒœê·¸ì˜ ì‚¬ìš©ì„ ì£¼ëª©í•˜ë¼."
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr "<literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, ê·¸ë¦¬ê³ <literal>UserVersionType</literal> ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì€ ë” ë§Žì€ íŠ¹í™”ëœ ì‚¬ìš©ë“¤ì„ ìœ„í•œ 지ì›ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "ë‹¹ì‹ ì€ ë§¤í•‘ íŒŒì¼ ì†ì— <literal>UserType</literal>ì— ëŒ€í•œ 파ë¼ë¯¸í„°ë“¤ì„ ì œê³µí• ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì„ 행하기 위해, ë‹¹ì‹ ì˜ <literal>UserType</literal>ì€ <literal>org.hibernate.usertype.ParameterizedType</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현해야 한다. ë‹¹ì‹ ì˜ ë§žì¶¤í˜• íƒ€ìž…ì— íŒŒë¼ë¯¸í„°ë“¤ì„ ì œê³µí•˜ê¸° 위해, ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ë§¤í•‘ 파ì¼ë“¤ ì†ì— <literal><type></literal> 요소를 ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr "<literal>UserType</literal>ì€ ì´ì œ ê·¸ê²ƒì— ì „ë‹¬ëœ <literal>Properties</literal> ê°ì²´ë¡œë¶€í„° <literal>default</literal>ë¡œ ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ì— 대한 ê°’ì„ ê²€ìƒ‰í• ìˆ˜ 있다."
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë§¤ìš° ìžì£¼ ì–´ë–¤ UserTypeì„ ì‚¬ìš©í• ê²½ìš°, ê·¸ê²ƒì€ ê·¸ê²ƒì— ëŒ€í•œ ë” ì§§ì€ ì´ë¦„ì„ ì •ì˜í•˜ëŠ” ê²ƒì´ ìœ ìš©í• ìˆ˜ 있다. <literal><typedef></literal> 요소를 사용하여 ì´ê²ƒì„ í–‰í• ìˆ˜ 있다. Typedefë“¤ì€ ì´ë¦„ì„ ë§žì¶¤í˜• íƒ€ìž…ì— í• ë‹¹í•˜ê³ , ë˜í•œ ë§Œì¼ ê·¸ íƒ€ìž…ì´ íŒŒë¼ë¯¸í„°í™” ëœ ê²½ìš°ì— ë””í´íŠ¸ 파ë¼ë¯¸í„° ê°’ë“¤ì˜ ë¦¬ìŠ¤íŠ¸ë¥¼ í¬í•¨í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+
+#: index.docbook:2630
+msgid "binary"
+msgstr "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr "property 매핑 ìƒì— type 파ë¼ë¯¸í„°ë“¤ì„ ì‚¬ìš©í•¨ìœ¼ë¡œì¨ ê²½ìš°ì— ë§žê²Œ typedef ë‚´ì— ì œê³µëœ íŒŒë¼ë¯¸í„°ë“¤ì„ 오버ë¼ì´ë“œ 시키는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:2638
+msgid "text"
+msgstr "ë¹„ë¡ Hibernateì˜ í’부한 ë²”ìœ„ì˜ ë¯¸ë¦¬ 만들어진 타입들과 ì»´í¬ë„ŒíŠ¸ë“¤ì— 대한 지ì›ì´ ë‹¹ì‹ ì´ ê°€ë” ë§žì¶¤í˜• íƒ€ìž…ì„ ì‚¬ìš©í• <emphasis>필요가</emphasis> ê±°ì˜ ì—†ì„ ê²ƒìž„ì„ ì˜ë¯¸í• 지ë¼ë„, 그럼ì—ë„ ë¶ˆêµ¬í•˜ê³ ê·¸ê²ƒì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—ì„œ ìžì£¼ ë°œìƒí•˜ëŠ” (엔티티가 ì•„ë‹Œ) í´ëž˜ìŠ¤ë“¤ì— 대해 맞춤형 íƒ€ìž…ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ì¢‹ì€ í˜•ì‹ìœ¼ë¡œ 간주ëœë‹¤. 예를 들어 <literal>MonetaryAmount</literal> í´ëž˜ìŠ¤ëŠ” ë¹„ë¡ ê·¸ê²ƒì´ ì»´í¬ë„ŒíŠ¸ë¡œì„œ 쉽게 매핑ë 수 있ì„지ë¼ë„, <literal>CompositeUserType</literal>ì— ëŒ€í•œ ì¢‹ì€ í›„ë³´ì´ë‹¤. ì´ê²ƒì— 대한 í•˜ë‚˜ì˜ ë™ê¸°ëŠ” 추ìƒí™”ì´ë‹¤. 맞춤형 타입으로, ë‹¹ì‹ ì˜ ë§¤í•‘ ë¬¸ì„œë“¤ì€ í™”í ê°’ë“¤ì„ í‘œí˜„í•˜ëŠ” ë‹¹ì‹ ì˜ ë°©ë²•ì—ì„œ 가능한 ë³€ê²½ë“¤ì— ëŒ€í•´ 장차 ê²€ì¦ë 것ì´ë‹¤."
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr "í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ë¥¼ í•œ 번 ì´ìƒ 매핑하기"
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr "í•˜ë‚˜ì˜ íŠ¹ì •í•œ ì˜ì† í´ëž˜ìŠ¤ì— 대해 하나 ì´ìƒì˜ ë§¤í•‘ì„ ì œê³µí•˜ëŠ” ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. ì´ ê²½ìš°ì— ë‹¹ì‹ ì€ ë‘ ê°œì˜ ë§¤í•‘ëœ ì—”í‹°í‹°ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ 사ì´ë¥¼ 명확하게 하기 위해 <emphasis>í•˜ë‚˜ì˜ ì—”í‹°í‹° ì´ë¦„</emphasis>ì„ ì§€ì •í•´ì•¼ 한다. (ë””í´íŠ¸ë¡œ, 엔티티 ì´ë¦„ì€ í´ëž˜ìŠ¤ ì´ë¦„ê³¼ ë™ì¼í•œ 것ì´ë‹¤.) Hibernate는 ì˜ì† ê°ì²´ë“¤ì— 대해 ìž‘ì—…í• ë•Œ, 질ì˜ë“¤ì„ ìž‘ì„±í• ë•Œ, ë˜ëŠ” ëª…ëª…ëœ ì—”í‹°í‹°ì— ëŒ€í•œ ì—°ê´€ë“¤ì„ ë§¤í•‘í• ë•Œ ë‹¹ì‹ ìœ¼ë¡œ 하여금 엔티티 ì´ë¦„ì„ ì§€ì •í•˜ë„ë¡ í•œë‹¤."
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\" \n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\" \n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\" \n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\" \n"
+ " column=\"currentContractId\" \n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr "ì—°ê´€ë“¤ì€ ì´ì œ <literal>class</literal> ëŒ€ì‹ ì— <literal>entity-name</literal>ì„ ì‚¬ìš©í•˜ì—¬ 어떻게 ì§€ì •ë˜ëŠ”지를 주목하ë¼."
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr "SQL ì¸ìš©ë¶€í˜¸ í‘œì‹œëœ ì‹ë³„ìžë“¤"
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr "ë‹¹ì‹ ì€ ë§¤í•‘ 문서 ë‚´ì—ì„œ í…Œì´ë¸” ë˜ëŠ” 컬럼 ì´ë¦„ì„ ì—ì¸ìš©ê¸°í˜¸(`)들 ì†ì— 넣어서 ìƒì„±ëœ SQLì—ì„œ ì‹ë³„ìžë¥¼ ì¸ìš©ë¶€í˜¸ 처리하ë„ë¡ Hibernateì—게 ê°•ì œí• ìˆ˜ë„ ìžˆë‹¤. Hibernate는 SQL <literal>Dialect</literal>ì— ëŒ€í•´ ì •í™•í•œ ì¸ìš© 스타ì¼ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤(대개 ì´ì¤‘ ì¸ìš©ë¶€í˜¸ ì´ì§€ë§Œ, SQL Serverì˜ ê²½ìš°ì—는 모난 괄호들ì´ê³ MySQLì˜ ê²½ìš°ì—는 ì—ì¸ìš©ë¶€í˜¸(`))."
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr "Metadata 대안들"
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr "XMLì€ ëª¨ë“ ì‚¬ëžŒë“¤ì„ ìœ„í•œ ê²ƒì´ ì•„ë‹ˆì§€ë§Œ, Hibernateì—ì„œ O/R 매핑 메타ë°ì´í„°ë¥¼ ì •ì˜í•˜ëŠ” 몇몇 대안ì ì¸ ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr "XDoclet 마í¬ì—… 사용하기"
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr "ë§Žì€ Hibernate 사용ìžë“¤ì€ XDoclet <literal>@hibernate.tags</literal>를 사용하여 소스 코드 ì†ì— ì§ì ‘ 매핑 ì •ë³´ë¥¼ 삽입시키는 ê²ƒì„ ì„ í˜¸í•œë‹¤. 우리는 ì´ ë¬¸ì„œì—ì„œ ì´ ì ‘ê·¼ë²•ì„ ë‹¤ë£¨ì§€ ì•Šì„ ê²ƒì´ë‹¤. 왜ëƒí•˜ë©´ ê·¸ê²ƒì€ ì—„ê²©í•˜ê²ŒëŠ” XDocletì˜ ë¶€ë¶„ìœ¼ë¡œ 간주ë˜ê¸° 때문ì´ë‹¤. 하지만 우리는 XDoclet ë§¤í•‘ë“¤ì„ ê°€ì§„ <literal>Cat</literal> í´ëž˜ìŠ¤ì— 관한 ë‹¤ìŒ ì˜ˆì œë¥¼ í¬í•¨í•œë‹¤."
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr "XDocletê³¼ ibernateì— ê´€í•œ 추가 ì˜ˆì œë“¤ì€ Hibernate 웹 사ì´íŠ¸ë¥¼ ë³´ë¼."
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr "JDK 5.0 Annotations 사용하기"
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr "JDK 5.0ì€ ì–¸ì–´ ë ˆë²¨ì—ì„œ XDoclet-스타ì¼ì˜ 주ì„들, type-safe와 ì»´íŒŒì¼ ì‹œ ì²´í‚¹ì„ ë„입했다. ì´ ë©”ì»¤ë‹ˆì¦˜ì€ XDoclet 주ì„들 보다 ë” ê°•ë ¥í•˜ë©° ë„구들과 IDEë“¤ì— ì˜í•´ ë” ì¢‹ê²Œ 지ì›ëœë‹¤. 예를 들어 IntelliJ IDEA는 JDK 5.0 주ì„ë“¤ì— ëŒ€í•œ ìžë™-완성 기능과 구문 강조를 지ì›í•œë‹¤. EJB ëª…ì„¸ì„œì˜ ìƒˆë¡œìš´ ê°œì •íŒ(JSR-220)ì€ ì—”í‹°í‹° ë¹ˆì¦ˆì— ëŒ€í•œ 프ë¼ì´ë¨¸ë¦¬ 메타ë°ì´í„° 메커니즘으로서 JDK 5.0 Annotationsì„ ì‚¬ìš©í•œë‹¤. Hibernate3는 JSR-220(ì˜ì† API)ì˜ <literal>EntityManager</literal>를 êµ¬í˜„í•˜ê³ , 매핑 메타ë°ì´í„°ì— 대한 지ì›ì€ 별ë„ì˜ ë‚´ë ¤ë°›ê¸°ë¡œì„œ <emphasis>Hibernate Annotations</emphasis> 패키지를 통해 ì´ìš© 가능하다. EJB3 (JSR-220)ê³¼ Hibernate3 metadata ì–‘ìžê°€ 지ì›ëœë‹¤."
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr "다ìŒì€ EJB 엔티티 빈으로서 주ì„ì´ ë¶™ì€ POJO í´ëž˜ìŠ¤ì— 관한 ì˜ˆì œì´ë‹¤:"
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr "JDK 5.0 Annotations(ê·¸ë¦¬ê³ JSR-220)ì— ëŒ€í•œ 지ì›ì€ ì—¬ì „ížˆ ìž‘ì—…ì´ ì§„í–‰ 중ì´ê³ 완성ë˜ì§€ 않았ìŒì„ 노트하ë¼. ìƒì„¸í•œ ê²ƒì€ Hibernate Anotations를 참조하ë¼."
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr "산출ë˜ëŠ” 프로í¼í‹°ë“¤"
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr "산출ë˜ëŠ” 프로í¼í‹°ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ 산출ë˜ëŠ” ê·¸ê²ƒë“¤ì˜ ê°’ë“¤ì„ ê°–ëŠ” 프로í¼í‹°ë“¤ì´ë‹¤. ì „í˜•ì 으로, Hibernate 어플리케ì´ì…˜ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ê°€ ê°’ë“¤ì„ ìƒì„±ì‹œì¼°ë˜ ìž„ì˜ì˜ 프로í¼í‹°ë“¤ì„ í¬í•¨í•˜ëŠ” ê°ì²´ë“¤ì„ <literal>ê°±ì‹ </literal>시킬 필요가 있었다.하지만 generatedë¡œ 마í¬ëœ 프로í¼í‹°ë“¤ì€ 어플리케ì´ì…˜ìœ¼ë¡œ 하여금 ì´ ì±…ìž„ì„ Hibernateì—게 위임시키ë„ë¡ í•œë‹¤. 본질ì 으로 Hibernateê°€ 산출ë˜ëŠ” 프로í¼í‹°ë“¤ì„ ì •ì˜í–ˆë˜ ì—”í‹°í‹°ì— ëŒ€í•´ SQL INSERT ë˜ëŠ” UPDATE ëª…ë ¹ì„ ë‚´ë¦´ 때마다 바로 ì§í›„ì— ì‚°ì¶œë˜ëŠ” ê°’ë“¤ì„ ê²€ìƒ‰í•˜ê¸° 위해 í•˜ë‚˜ì˜ select ëª…ë ¹ì„ ë‚´ë¦°ë‹¤."
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr "generatedë¡œ 마í¬ëœ 프로í¼í‹°ë“¤ì€ 부가ì 으로 inser 가능하지 않아야 í•˜ê³ update 불가능해야 한다. ì˜¤ì§ Properties marked as generated must additionally be non-insertable and non-updateable. <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, ê·¸ë¦¬ê³ <xref linkend=\"mapping-declaration-property\"/>단순 프로í¼í‹°ë“¤ ë§Œì´ generatedë¡œ 마í¬ë 수 있다."
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr "<literal>never</literal> (ë””í´íŠ¸) - 는 주어진 프로í¼í‹° ê°’ì´ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ìƒì„±ë˜ì§€ ì•Šì„ ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr "<literal>insert</literal> - 는 주어진 프로í¼í‹° ê°’ì´ insert ì‹œì— ìƒì„±ë˜ì§€ë§Œ, ì°¨í›„ì˜ ì—…ë°ì´íŠ¸ë“¤ì—ì„œ 다시 ìƒì„±ë˜ì§€ ì•Šì„ ê²ƒìž„ì„ ê¸°ìˆ í•œë‹¤. ìƒì„±-ë‚ ì§œì™€ ê°™ì€ ê²ƒë“¤ì´ ì´ ì¹´í…Œê³ ë¦¬ ë‚´ë¡œ í¬í•¨ë 것ì´ë‹¤. ë¹„ë¡ <xref linkend=\"mapping-declaration-version\"/>versionê³¼ <xref linkend=\"mapping-declaration-timestamp\"/>timestamp 프로í¼í‹°ë“¤ì´ ìƒì„±ë˜ëŠ” 것으로서 마í¬ë 수 ìžˆì„ ì§€ë¼ë„, ì´ ì˜µì…˜ì€ ê±°ê¸°ì„œ ì´ìš© ë¶ˆê°€ëŠ¥í•¨ì„ ë…¸íŠ¸í•˜ë¼..."
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr "<literal>always</literal> - 는 프로í¼í‹° ê°’ì´ insert 시와 update ì‹œ 모ë‘ì— ìƒì„±ë¨ì„ ê¸°ìˆ í•œë‹¤."
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr "ë³´ì¡° ë°ì´í„°ë² ì´ìŠ¤ ê°ì²´ë“¤"
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr "Hibernate 매핑 파ì¼ë“¤ ë‚´ì— ì‚¬ìš©ìž ìŠ¤í‚¤ë§ˆë¥¼ ì™„ì „í•˜ê²Œ ì •ì˜í•˜ê¸° 위한 ëŠ¥ë ¥ì„ ì œê³µí•˜ê¸° 위해서, Hibernateì˜ ìŠ¤í‚¤ë§ˆ 방출 ë„구들과 함께 ìž„ì˜ì ì¸ ë°ì´í„°ë² ì´ìŠ¤ ê°ì²´ë“¤ì— 대한 CREATE와 DROPì„ í—ˆìš©í•´ì¤€ë‹¤. ë¹„ë¡ íŠ¸ë¦¬ê±°ë“¤ ë˜ëŠ” 내장 í”„ë¡œì‹œì €ë“¤ê³¼ ê°™ì€ ê²ƒë“¤ì„ ìƒì„±ì‹œí‚¤ê³ ë“œë¡ì‹œí‚¤ê¸° ì´í•´ 특별히 ê³ ì•ˆë˜ì—ˆì„지ë¼ë„ í•˜ë‚˜ì˜ <literal>java.sql.Statement.execute()</literal> 메소드를 통해 실행ë 수 있는 SQL ëª…ë ¹ì´ ì—¬ê¸°ì„œ ìœ íš¨í•˜ë‹¤(ALTERs, INSERTS, 기타). ë³´ì¡° ë°0ì´í„°ë² ì´ìŠ¤ ê°ì²´ë“¤ì„ ì •ì˜í•˜ëŠ” ë‘ ê°€ì§€ ëª¨ë“œë“¤ì´ ë³¸ì§ˆì 으로 존재한다..."
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr "첫 번째 모드는 매핑 íŒŒì¼ ë°”ê¹¥ì—ì„œ CREATE ë° DROP ëª…ë ¹ë“¤ì„ ëª…ì‹œì 으로 나열하는 것ì´ë‹¤:"
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr "ë‘번째 모드는 CREATE ë° DROP ëª…ë ¹ë“¤ì„ ìƒì„±ì‹œí‚¤ëŠ” ë°©ë²•ì„ ì•Œê³ ìžˆëŠ” í•˜ë‚˜ì˜ ë§žì¶¤ í´ëž˜ìŠ¤ë¥¼ ì œê³µí•˜ëŠ” 것ì´ë‹¤. ì´ ë§žì¶¤ í´ëž˜ìŠ¤ëŠ” <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현해야 한다."
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr "ë§ë¶™ì—¬ ì´ë“¤ ë°ì´í„°ë² ì´ìŠ¤ ê°ì²´ë“¤ì€ ì–´ë–¤ dialectë“¤ì´ ì‚¬ìš©ë ë•Œ ê·¸ê²ƒë“¤ì´ ë‹¨ì§€ ì ìš©ë 수 있ë„ë¡ ì„ íƒì 으로 ë³€ë™ë 수 있다."
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,374 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr "Batch 처리"
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr "Hibernate를 사용하여 ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ 100 000 ê°œì˜ í–‰ë“¤ì„ ì‚½ìž…ì‹œí‚¤ëŠ” ë³¸ëž˜ì˜ ì ‘ê·¼ë²•ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr "ì´ê²ƒì€ 50 000번째 í–‰ 가까운 ê³³ì—ì„œ <literal>OutOfMemoryException</literal>으로 떨어질 것ì´ë‹¤. ê·¸ê²ƒì€ Hibernateê°€ session-level ìºì‹œ ì†ì— ëª¨ë“ ìƒˆë¡œì´ ì‚½ìž…ëœ <literal>Customer</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ìºì‹œì‹œí‚¤ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr "ì´ ìž¥ì—ì„œ 우리는 ì´ ë¬¸ì œë¥¼ 피하는 ë°©ë²•ì„ ë‹¹ì‹ ì—게 보여줄 것ì´ë‹¤. 하지만 ë¨¼ì € ë‹¹ì‹ ì´ ë°°ì¹˜ 처리를 행하는 중ì´ë¼ë©´, ë‹¹ì‹ ì´ ì 당한 í¼í¬ë¨¼ìŠ¤ë¥¼ ì„±ì·¨í•˜ë ¤ê³ í• ê²½ìš°ì— ë‹¹ì‹ ì´ JDBC 배치 ì‚¬ìš©ì„ ê°€ëŠ¥í•˜ê²Œ 하는 ê²ƒì€ ì ˆëŒ€ì 으로 필요하다. JDBC 배치 사ì´ì¦ˆë¥¼ ì 당한 숫ìž(10-50)ë¡œ ì„¤ì •í•˜ë¼:"
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>identiy</literal> ì‹ë³„ìž ìƒì„±ìžë¥¼ ì‚¬ìš©í• ê²½ìš° Hibernateê°€ JDBC ë ˆë²¨ì—ì„œ 투명하게 insert ë°°ì¹˜ìž‘ì—…ì„ ì‚¬ìš©ë¶ˆê°€ëŠ¥í•˜ê²Œ 한다는 ì ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ second-level ìºì‹œë¥¼ 가진 ìƒí˜¸ìž‘ìš©ì´ ì™„ì „í•˜ê²Œ 불가능한 프로세스 ë‚´ì—ì„œ ì´ëŸ° ì¢…ë¥˜ì˜ ìž‘ì—…ì„ í–‰í•˜ê³ ì‹¶ì–´í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+
+#: index.docbook:41
+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 "하지만 ì´ê²ƒì€ ì ˆëŒ€ì 으로 필요하지 않다. 왜ëƒí•˜ë©´ 우리는 second-level ìºì‹œì™€ì˜ ìƒí˜¸ìž‘ìš©ì„ ë¶ˆê°€ëŠ¥í•˜ë„ë¡ í•˜ê¸° 위해 명시ì 으로 <literal>CacheMode</literal>를 ì„¤ì •í• ìˆ˜ 있기 때문ì´ë‹¤."
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr "Batch inserts"
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr "새로운 ê°ì²´ë“¤ì„ ì˜ì†í™” 시킬 ë•Œ, ë‹¹ì‹ ì€ first-level ìºì‹œì˜ 사ì´ì¦ˆë¥¼ ì œì–´í•˜ê¸° 위해 ì„¸ì…˜ì„ ì •ê¸°ì 으로 <literal>flush()</literal> ì‹œí‚¤ê³ ë‚˜ì„œ <literal>clear()</literal> 시켜야 한다."
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr "Batch updates"
+
+#: index.docbook:62
+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>ì„ ì‚¬ìš©í• í•„ìš”ê°€ 있다."
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr "StatelessSession ì¸í„°íŽ˜ì´ìŠ¤"
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr "다른 방법으로 Hibernate는 분리ëœ(detached) ê°ì²´ë“¤ì˜ 형ì‹ìœ¼ë¡œ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ê·¸ë¦¬ê³ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ë°ì´í„°ë¥¼ 스트리ë°í•˜ëŠ”ë° ì‚¬ìš©ë 수 있는 í•˜ë‚˜ì˜ ëª…ë ¹ 지향 API를 ì œê³µí•œë‹¤. <literal>StatelessSession</literal>ì€ ê·¸ê²ƒê³¼ ì—°ê´€ëœ ì˜ì† 컨í…스트를 갖지 ì•Šê³ ë§Žì€ ë³´ë‹¤ ë†’ì€ ë ˆë²¨ì˜ ìƒëª… 주기 ì˜ë¯¸ë¥¼ ì œê³µí•˜ì§€ 않는다. 특히 í•˜ë‚˜ì˜ ìƒíƒœ 없는 ì„¸ì…˜ì€ ì²« 번째 ë ˆë²¨ ìºì‹œë¥¼ 구현하지 않거나 ìž„ì˜ì˜ ë‘ ë²ˆì§¸ ë ˆë²¨ ìºì‹œ ë˜ëŠ” ì§ˆì˜ ìºì‹œì™€ ìƒí˜¸ìž‘용하지 않는다. ê·¸ê²ƒì€ ì „í†µì ì¸ ì“°ê¸°-ì´ë©´(write-behind)ì˜ ì²´í‚¹ì´ë‚˜ ìžë™ì ì¸ dirty ì²´í‚¹ì„ êµ¬í˜„í•˜ì§€ 않는다. í•˜ë‚˜ì˜ ìƒíƒœ 없는 ì„¸ì…˜ì„ ì‚¬ìš©í•˜ì—¬ ìˆ˜í–‰ëœ ì—°ì‚°ë“¤ì€ ì—°ê´€ëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대해 케스케ì´ë“œ ë˜ì§€ 않는다. ì½œë ‰ì…˜ë“¤ì€ ìƒíƒœ 없는 ì„¸ì…˜ì— ì˜í•´ 무시ëœë‹¤. ìƒíƒœì—†ëŠ” ì„¸ì…˜ì„ í†µí•´ ìˆ˜í–‰ëœ ì—°ì‚°ë“¤ì€ Hibernateì!
˜ ì´ë²¤íŠ¸ 모형과 ì¸í„°ì…‰í„°ë“¤ì„ 우회한다. ìƒíƒœì—†ëŠ” ì„¸ì…˜ë“¤ì€ ì²«ë²ˆì§¸-ë ˆë²¨ì˜ ìºì‹œì˜ 부족으로 ì¸í•´ ë°ì´í„° alias íš¨ê³¼ë“¤ì— ì·¨ì•½í•˜ë‹¤. ìƒíƒœì—†ëŠ” ì„¸ì…˜ì€ ê¸°ë³¸ JDBCì— í›¨ì”¬ ë” ê°€ê¹Œìš´ í•˜ë‚˜ì˜ ë³´ë‹¤ ë‚®ì€ ë ˆë²¨ì˜ ì¶”ìƒí™”(abstraction)ì´ë‹¤."
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:91
+msgid "Note that 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> ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ê³§ë°”ê³ ë¶„ë¦¬ëœë‹¤(detached). ê·¸ê²ƒë“¤ì€ ìž„ì˜ì˜ ì˜ì† 컨í…스트와 ê²°ì½” ì—°ê´€ë˜ì§€ 않는다."
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very 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> ì—°ì‚°ë“¤ì€ ì§ì ‘ì ì¸ ë°ì´í„°ë² ì´ìŠ¤ ì €ê¸‰ 연산들로 갖주ë˜ê³ , ê·¸ê²ƒì€ ê°ê° í•˜ë‚˜ì˜ SQL <literal>INSERT, UPDATE</literal> ë˜ëŠ” <literal>DELETE</literal>ì˜ ì¦‰ê°ì ì¸ ì‹¤í–‰ìœ¼ë¡œ 귀결ëœë‹¤. ë”°ë¼ì„œ ê·¸ê²ƒë“¤ì€ <literal>Session</literal> ì¸í„°íŽ˜ì´ìŠ¤ì— ì˜í•´ ì •ì˜ëœ <literal>save(), saveOrUpdate()</literal>와 <literal>delete()</literal> 연산들과는 매우 다른 ì˜ë¯¸ë“¤ì„ 갖는다."
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr "DML-ìŠ¤íƒ€ì¼ ì—°ì‚°ë“¤"
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr "ì´ë¯¸ ë…¼ì˜í–ˆë“¯ì´, ìžë™ì ì´ê³ 투명한 ê°ì²´/관계형 ë§¤í•‘ì€ ê°ì²´ ìƒíƒœì— 대한 ê´€ë¦¬ì— ê´€ê³„ëœë‹¤. ì´ê²ƒì€ ê°ì²´ ìƒíƒœê°€ 메모리 ë‚´ì—ì„œ ì´ìš© ê°€ëŠ¥í•¨ì„ ì˜ë¯¸í•˜ë¯€ë¡œ, (SQL <literal>Data Manipulation Language</literal>(DML) 문장들 : <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>를 사용하여) ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ì§ì ‘ ë°ì´í„°ë¥¼ ì—…ë°ì´íŠ¸í•˜ê±°ë‚˜ ì‚ì œí•˜ëŠ” ê²ƒì€ ë©”ëª¨ë¦¬ ë‚´ ìƒíƒœì— ì˜í–¥ì„ 주지 ì•Šì„ ê²ƒì´ë‹¤. 하지만 Hibernate는 Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)를 통해 실행ë˜ëŠ” 대량 SQL-스타ì¼ì˜ DML 문장 ì‹¤í–‰ì„ ìœ„í•œ ë©”ì†Œë“œë“¤ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr "<literal>UPDATE</literal>와 <literal>DELETE</literal> ë¬¸ìž¥ë“¤ì— ëŒ€í•œ ìœ ì‚¬ êµ¬ë¬¸ì€ ë‹¤ìŒê³¼ 같다: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. ë…¸íŠ¸í• ëª‡ 가지:"
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr "from-ì ˆì—ì„œ, FROM 키워드는 옵션ì´ë‹¤"
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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-ì ˆ ë‚´ì— í•œ ê°œì˜ ëª…ëª…ëœ ì—”í‹°í‹°ê°€ ì˜¤ì§ ì¡´ìž¬í• ìˆ˜ 있다; ê·¸ê²ƒì€ ì„ íƒì 으로 aliasë 수 있다. ë§Œì¼ ì—”í‹°í‹° ì´ë¦„ì´ aliasë˜ë©´, 그때 ìž„ì˜ì˜ 프로í¼í‹° ì°¸ì¡°ë“¤ì€ ê·¸ alias를 사용하여 수ì‹ë˜ì–´ì•¼ 한다; ë§Œì¼ ì—”í‹°í‹° ì´ë¦„ì´ aliasë˜ì§€ ì•Šì„ ê²½ìš°, ìž„ì˜ì˜ 프로í¼í‹° ì°¸ì¡°ë“¤ì— ëŒ€í•´ 수ì‹ë˜ëŠ” ê²ƒì€ ê·œì¹™ì— ì–´ê¸‹ë‚œë‹¤."
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr "joinë“¤ì€ (함축ì ì´ë“ 명시ì ì´ë“ ) 대량 HQL ì§ˆì˜ ì†ì— ì§€ì •ë 수 없다. 서브-질ì˜ë“¤ì´ where-ì ˆì— ì‚¬ìš©ë 수 있다; 서브질ì˜ë“¤ ê·¸ ìžì‹ ë“¤ì€ ì¡°ì¸ë“¤ì„ í¬í•¨í• 수 있다."
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr "where-ì ˆ ë˜í•œ 옵션ì´ë‹¤."
+
+#: index.docbook:156
+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 "í•˜ë‚˜ì˜ ì˜ˆì œë¡œì„œ, í•œ ê°œì˜ HQL <literal>UPDATE</literal>를 실행하기 위해, <literal>Query.executeUpdate()</literal> 메소드(ì´ ë©”ì†Œë“œëŠ” JDBCì˜ <literal>PreparedStatement.executeUpdate()</literal>와 ìœ ì‚¬í•˜ê²Œ 명명ëœë‹¤)를 사용하ë¼:"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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\"/>version ë˜ëŠ” <xref linkend=\"mapping-declaration-timestamp\"/>timestamp 프로í¼í‹° ê°’ë“¤ì— ì˜í–¥ì„ 주지 않는다; ì´ê²ƒì€ EJB3 명세서ì—ì„œ ìœ ì§€ë˜ê³ 있다. 하지만 ë‹¹ì‹ ì€ í•˜ì´ë²„네ì´íŠ¸ë¡œ 하여금 <literal>versioned update</literal>ì˜ ì‚¬ìš©ì„ í†µí•´ <literal>version</literal> ë˜ëŠ” <literal>timestamp</literal> 프로í¼í‹° ê°’ë“¤ì„ ì ì ˆí•˜ê²Œ ìž¬ì„¤ì •í•˜ë„ë¡ ê°•ì œí• ìˆ˜ 있다. ì´ê²ƒì€ <literal>UPDATE</literal> 키워드 ë’¤ì— <literal>VERSIONED</literal> 키워드를 추가시켜서 성취ëœë‹¤."
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr "맞춤형 version 타입들(<literal>org.hibernate.usertype.UserVersionType</literal>)ì€ <literal>update versioned</literal> 문장과 함께 사용하는 ê²ƒì´ í—ˆìš©ë˜ì§€ ì•ŠìŒì„ 노트하ë¼."
+
+#: index.docbook:181
+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>를 사용하ë¼:"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr "<literal>Query.executeUpdate()</literal> ë©”ì†Œë“œì— ì˜í•´ 반환ë˜ëŠ” <literal>int</literal> ê°’ì€ ê·¸ 오í¼ë ˆì´ì…˜ì— ì˜í•´ ì˜í–¥ë°›ì€ ì—”í‹°í‹°ë“¤ì˜ ê°œìˆ˜ë¥¼ 나타낸다. ì´ê²ƒì´ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ ì˜í–¥ë°›ì€ í–‰ë“¤ì˜ ê°œìˆ˜ì™€ ìƒê´€ì´ 있는지 없는지 여부를 살펴보ìž. HQL 대량 오í¼ë ˆì´ì…˜ì€ 예를 들어 joined-subclassì˜ ê²½ìš°ì— ì‹¤í–‰ ì¤‘ì¸ ì—¬ëŸ¬ ê°œì˜ ì‹¤ì œ SQL 문장들로 귀결ë 수 있다. 반환ë˜ëŠ” 숫ìžëŠ” ê·¸ ë¬¸ìž¥ì— ì˜í•´ ì˜í–¥ë°›ì€ ì‹¤ì œ ì—”í‹°í‹°ë“¤ì˜ ê°œìˆ˜ë¥¼ 나타낸다. joined-subclass ì˜ˆì œë¡œ ë˜ëŒì•„가면, 서브 í´ëž˜ìŠ¤ë“¤ 중 í•˜ë‚˜ì— ëŒ€í•œ ì‚ì œëŠ” 단지 ê·¸ 서브í´ëž˜ìŠ¤ê°€ 매핑ë˜ì–´ 있는 í…Œì´ë¸”ì— ëŒ€í•œ ì‚ì œ ë¿ë§Œ ì•„ë‹ˆë¼ ë˜í•œ \"루트\" í…Œì´ë¸”ê³¼ ìƒì† 계층ì—ì„œ ë” ë‚´ë ¤ì˜¨ ìž ì •ì 으로 ì¡°ì¸ëœ-서브í´ëž˜ìŠ¤ í…Œì´ë¸”ë“¤ì— ëŒ€í•œ ì‚ì œë“¤ë¡œ 귀결ë 수 있다."
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr "ìž¥ëž˜ì˜ ë°°í¬ë³¸ë“¤ì—ì„œ ì „ë‹¬ë 대량 HQL 오í¼ë ˆì´ì…˜ë“¤ì— 대한 몇 가지 ì œí•œë“¤ì´ í˜„ìž¬ ì¡´ìž¬í•¨ì„ ë…¸íŠ¸í•˜ë¼; ìƒì„¸í•œ ê²ƒì€ JIRA ë¡œë“œë§µì„ ì°¸ì¡°í•˜ë¼. <literal>INSERT</literal> ë¬¸ìž¥ë“¤ì„ ìœ„í•œ ìœ ì‚¬-êµ¬ë¬¸ì€ ë‹¤ìŒê³¼ 같다: <literal>INSERT INTO EntityName properties_list select_statement</literal>. ë…¸íŠ¸í• ëª‡ 가지:"
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr "ì˜¤ì§ INSERT INTO ... SELECT ... í˜•ì‹ ë§Œì¼ ì§€ì›ëœë‹¤; INSERT INTO ... VALUES ... 형ì‹ì€ 지ì›ë˜ì§€ 않는다."
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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> ë¬¸ìž¥ë“¤ì€ ë³¸ëž˜ì 으로 다형ì ì´ì§€ 않다."
+
+#: index.docbook:220
+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. Note however that this might 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는 반환 íƒ€ìž…ë“¤ì´ insertì— ì˜í•´ 기대ë˜ëŠ” 타입들과 ì¼ì¹˜í•´ì•¼ 한다는 단서 í•˜ì— ìž„ì˜ì˜ ìœ íš¨í•œ HQL select 질ì˜ì¼ 수 있다. 현재 ì´ê²ƒì€ ì²´í¬ë¥¼ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ì´ê´€ì‹œí‚¤ëŠ” ê²ƒì„ í—ˆìš©í•˜ê¸° 보다는 ì§ˆì˜ ì»´íŒŒì¼ ë™ì•ˆì— ì²´í¬ëœë‹¤. 하지만 ì´ê²ƒì€ <emphasis>equal</emphasis>과는 대조ì 으로 <emphasis>등가ì¸(equivalent)</emphasis> Hibernate <literal>Type</literal>들 사ì´ì—ì„œ ë¬¸ì œì ë“¤ì„ ì¼ìœ¼í‚¬ ìˆ˜ë„ ìžˆìŒì„ 노트하ë¼. ë¹„ë¡ ë°ì´í„°ë² ì´ìŠ¤ê°€ 구별짓지 ì•Šì„ ìˆ˜ 있거나 ë³€í™˜ì„ ì²˜ë¦¬í• ìˆ˜ ìžˆì„ ì§€ë¼ë„, ì´ê²ƒì€ <literal>org.hibernate.type.DateType</literal>로서 ì •ì˜ëœ 프로í¼í‹°ì™€ <literal>org.hibernate.type.TimestampType</literal>으로 ì •ì˜ëœ 프로í¼í‹° 사ì´ì— 불ì¼ì¹˜ ìŸì ë“¤ì„ ì¼ìœ¼í‚¨ë‹¤."
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ì—°ì‚°ìžë“¤ì„ ì‚¬ìš©í• ë•Œì—만 ì´ìš© 가능하다; ìž„ì˜ì˜ \"메모리 ë‚´\" 타입 ì—°ì‚°ìžë“¤ê³¼ 함께 ì´ ì˜µì…˜ì„ ì‚¬ìš©í•˜ë ¤ê³ ì‹œë„하는 ê²ƒì€ íŒŒì‹± ë™ì•ˆì— 예외ìƒí™©ì„ ì¼ìœ¼í‚¬ 것ì´ë‹¤. ì´ ë…¼ì˜ì˜ 목ì ìƒ, ë°ì´í„°ë² ì´ìŠ¤ ë‚´ 산출ìž(generator)ë“¤ì€ <literal>org.hibernate.id.SequenceGenerator</literal> (ê·¸ë¦¬ê³ ê·¸ê²ƒì˜ ì„œë¸Œí´ëž˜ìŠ¤ë“¤) ê·¸ë¦¬ê³ ìž„ì˜ì˜ <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal>ì˜ êµ¬í˜„ìžë“¤ì´ë¼ê³ 간주ë¨ì„ 노트하ë¼. 여기서 가장 주목í•!
만한 예외ìƒí™©ì€ ê·¸ê²ƒì´ ê·¸ê²ƒì˜ ê°’ë“¤ì„ ì–»ê¸° 위한 select 가능한 ë°©ë²•ì„ ë…¸ì¶œì‹œí‚¤ì§€ 않기 ë•Œë¬¸ã…‡ì— ì‚¬ìš©ë 수 없는 <literal>org.hibernate.id.TableHiLoGenerator</literal>ì´ë‹¤."
+
+#: index.docbook:247
+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> ê°’ì´ ì‚¬ìš©ë˜ëŠ” 경우)."
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr "ì˜ˆì œ HQL <literal>INSERT</literal> 문장 실행:"
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr "최ìƒì˜ ì‹¤ì „ 경험들"
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr "fine-grained í´ëž˜ìŠ¤ë“¤ì„ ìž‘ì„±í•˜ê³ <literal><component></literal>를 사용하여 ê·¸ê²ƒë“¤ì„ ë§¤í•‘í•˜ë¼."
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr "<literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>를 캡ìŠí™” ì‹œí‚¤ëŠ”ë° <literal>Address</literal> í´ëž˜ìŠ¤ë¥¼ 사용하ë¼. ì´ê²ƒì€ 코드 ìž¬ì‚¬ìš©ì„±ì„ ì´‰ì§„ì‹œí‚¤ê³ ë¦¬íŒ©í† ë§ì„ 단순화 시킨다."
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대해 ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ ì„ ì–¸í•˜ë¼."
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr "Hibernate는 ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ 옵션으로 ë§Œë“ ë‹¤. 왜 우리가 ê·¸ê²ƒë“¤ì„ ì‚¬ìš©í•´ì•¼ í•˜ëŠ”ê°€ì— ëŒ€í•œ ëª¨ë“ ì¢…ë¥˜ì˜ ì´ìœ ë“¤ì´ ì¡´ìž¬í•œë‹¤. 우리는 ì‹ë³„ìžë“¤ì´ '합성(synthetic)'ì´ ë˜ëŠ”(비지니스 ì˜ë¯¸ ì—†ì´ ìƒì„±ë˜ëŠ”) ê²ƒì„ ê¶Œìž¥í•œë‹¤."
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr "ê³ ìœ í‚¤ë“¤ì„ ì‹ë³„하ë¼."
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr "ëª¨ë“ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ ê³ ìœ í‚¤ë“¤ì„ ì‹ë³„í•˜ê³ , <literal><natural-id></literal>를 사용하여 ê·¸ê²ƒë“¤ì„ ë§¤í•‘í•˜ë¼. ê³ ìœ í‚¤ë¥¼ 구성하는 프로í¼í‹°ë“¤ì„ 비êµí•˜ê¸° 위해 <literal>equals()</literal>와 <literal>hashCode()</literal>를 구현하ë¼."
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr "ê°ê°ì˜ í´ëž˜ìŠ¤ ë§¤í•‘ì„ ê·¸ê²ƒ ìžì‹ ì˜ íŒŒì¼ ë‚´ì— ìœ„ì¹˜ì§€ì›Œë¼."
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr "í•˜ë‚˜ì˜ í•œë©ì–´ë¦¬ 매핑 문서를 사용하지 ë§ë¼. <literal>com/eg/Foo.hbm.xml</literal> íŒŒì¼ ì†ì— <literal>com.eg.Foo</literal>를 매핑하ë¼. ì´ê²ƒì€ 팀 환경ì—ì„œ 특히 ì¢‹ì€ ì˜ë¯¸ë¥¼ 준다."
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr "ë§¤í•‘ë“¤ì„ ë¦¬ì†ŒìŠ¤ë“¤ë¡œì„œ 로드시켜ë¼."
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr "ê·¸ê²ƒë“¤ì´ ë§¤í•‘í•˜ëŠ” í´ëž˜ìŠ¤ë“¤ì— ë”°ë¼ì„œ ë§¤í•‘ë“¤ì„ ë°°ì¹˜í•˜ë¼"
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr "ì§ˆì˜ ë¬¸ìžì—´ë“¤ì„ ê°ê´€í™” 시키는 ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr "ë‹¹ì‹ ì˜ ì§ˆì˜ë“¤ì´ ANSI í‘œì¤€ì´ ì•„ë‹Œ SQL í•¨ìˆ˜ë“¤ì„ í˜¸ì¶œí•˜ëŠ” 경우는 ì¢‹ì€ ì‹¤ì „ì—°ìŠµì´ë‹¤. ì§ˆì˜ ë¬¸ìžì—´ë“¤ì„ 매핑 파ì¼ë“¤ì—다가 외부화 시키는 ê²ƒì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ 보다 ì´ì‹ì„± 있ë„ë¡ ë§Œë“¤ì–´ì¤„ 것ì´ë‹¤."
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr "ë°”ì¸ë“œ ë³€ìˆ˜ë“¤ì„ ì‚¬ìš©í•˜ë¼."
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr "JDBCì—서처럼, ìƒìˆ˜ ì•„ë‹Œ ê°’ë“¤ì„ \"?\"ë¡œ 대체시켜ë¼. ì§ˆì˜ ì†ì— ìƒìˆ˜ ì•„ë‹Œ ê°’ì„ ë°”ì¸ë“œ ì‹œí‚¤ëŠ”ë° ë¬¸ìžì—´ 처리를 ê²°ì½” 사용하지 ë§ë¼! ë” ì¢‹ê²ŒëŠ” 질ì˜ë“¤ ì†ì— ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ì„ 사용하는 ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr "ë‹¹ì‹ ìžì‹ ì˜ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ê´€ë¦¬í•˜ì§€ ë§ë¼."
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr "Hibernate는 어플리케ì´ì…˜ìœ¼ë¡œ 하여금 JDBC ì»¤ë„¥ì…˜ë“¤ì„ ê´€ë¦¬í•˜ë„ë¡ í•œë‹¤. ì´ ì ‘ê·¼ë²•ì€ ë§ˆì§€ë§‰ 수단으로서 ê³ ë ¤ë˜ì–´ì•¼ 한다. ë§Œì¼ ë‹¹ì‹ ì´ ë¯¸ë¦¬ 만들어진 커넥션 프로바ì´ë”ë“¤ì„ ì‚¬ìš©í• ìˆ˜ ì—†ì„ ê²½ìš°, <literal>org.hibernate.connection.ConnectionProvider</literal>ì— ëŒ€í•œ ë‹¹ì‹ ìžì‹ ì˜ êµ¬í˜„ì„ ì œê³µí•˜ëŠ” ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr "맞춤형 타입 ì‚¬ìš©ì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr "ë‹¹ì‹ ì´ ìžë°” íƒ€ìž…ì„ ê°–ê³ ìžˆê³ , ì–´ë–¤ ë¼ì´ë¸ŒëŸ¬ë¦¬ë¡œë¶€í„° ë§í•˜ê³ , ê·¸ê²ƒì´ ì˜ì†í™” ë 필요가 있지만 ê·¸ê²ƒì„ ì»´í¬ë„ŒíŠ¸ë¡œì„œ ë§¤í•‘ì‹œí‚¤ëŠ”ë° í•„ìš”í•œ accessorë“¤ì„ ì œê³µí• í•„ìš”ê°€ ì—†ë‹¤ê³ ê°€ì •í•˜ìž. ë‹¹ì‹ ì€ <literal>org.hibernate.UserType</literal>ì„ êµ¬í˜„í•˜ëŠ” ê²ƒì„ ê³ ë ¤í•´ì•¼ í• ê²ƒì´ë‹¤. ì´ ì ‘ê·¼ë²•ì€ Hibernate 타입으로/으로부터 ë³€í™˜ë“¤ì„ êµ¬í˜„í•˜ëŠ” 것으로부터 어플리케ì´ì…˜ 코드를 ìžìœ ë¡ê²Œ 해준다."
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr "병목 지ì 들ì—ì„œ 수작업으로 ì½”ë”©ëœ JDBC를 사용하ë¼."
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr "ì‹œìŠ¤í…œì˜ í¼í¬ë¨¼ìŠ¤ê°€ 중대한 ì˜ì—들ì—ì„œ, 몇몇 ì¢…ë¥˜ì˜ ì˜¤í¼ë ˆì´ì…˜ë“¤ì€ ì§ì ‘ì ì¸ JDBCì—ì„œ ì´ë“ì„ ë³¸ë‹¤. 그러나 ë‹¹ì‹ ì´ ì–´ë–¤ ê²ƒì´ ë³‘ëª©ì¸ì§€ë¥¼ <emphasis>알기</emphasis> ì „ê¹Œì§€ 기다리길 바란다. ê·¸ë¦¬ê³ ì§ì ‘ì ì¸ JDBCê°€ 반드시 ë” ë¹ ë¥´ë‹¤ê³ ê°€ì •í•˜ì§€ ë§ë¼. ë§Œì¼ ë‹¹ì‹ ì´ ì§ì ‘ì ì¸ JDBC를 ì‚¬ìš©í• í•„ìš”ê°€ ìžˆì„ ê²½ìš°, Hibernate <literal>Session</literal>ì„ ì—´ê³ ê·¸ SQL ì»¤ë„¥ì…˜ì„ ì‚¬ìš©í• ê°€ì¹˜ê°€ 있다. ê·¸ 방법으로 ë‹¹ì‹ ì€ ë™ì¼í•œ 트랜ìžì…˜ ë°©ë„와 기본 커넥션 프로바ì´ë”를 ì—¬ì „ížˆ ì‚¬ìš©í• ìˆ˜ 있다"
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr "<literal>Session</literal> flushingì„ ì´í•´í•˜ë¼."
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr "ì‹œê°„ì´ ì§€ë‚¨ì— ë”°ë¼ Sessionì€ ê·¸ê²ƒì˜ ì˜ì† ìƒíƒœë¥¼ ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ê¸°í™” 시킨다. ë§Œì¼ ì´ ê³¼ì •ì´ ë„ˆë¬´ ìžì£¼ ë°œìƒí• 경우 í¼í¬ë¨¼ìŠ¤ê°€ ì˜í–¥ì„ ë°›ì„ ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ ë•Œë•Œë¡œ ìžë™ì ì¸ flushingì„ ì‚¬ìš© 불가능하게 만들거나 íŠ¹ì • 트랜ìžì…˜ ë‚´ì—ì„œ 질ì˜ë“¤ì˜ 순서와 다른 오í¼ë ˆì´ì…˜ë“¤ì˜ 순서를 변경시켜서 불필요한 flushingì„ ìµœì†Œí™” 시킬 수 있다."
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr "3-tier 아키í…처ì—ì„œ, <literal>saveOrUpdate()</literal> ì‚¬ìš©ì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr "servlet / session 빈 아키í…처를 ì‚¬ìš©í• ë•Œ, ë‹¹ì‹ ì€ sesson bean ë‚´ì— ë¡œë“œëœ ì˜ì† ê°ì²´ë“¤ì„ 서블릿/JSP 계층으로/으로부터 ì „ë‹¬í• /ë°›ì„ ìˆ˜ 있다. ê°ê°ì˜ ìš”ì²ì„ ì„œë¹„ìŠ¤í•˜ëŠ”ë° ìƒˆë¡œìš´ ì„¸ì…˜ì„ ì‚¬ìš©í•˜ë¼. ê°ì²´ë“¤ì„ ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ê¸°í™” 시키기 위해서 <literal>Session.merge()</literal> ë˜ëŠ” <literal>Session.saveOrUpdate()</literal>를 사용하ë¼."
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr "2-tier 아키í…처ì—ì„œ, ìˆ˜ëª…ì´ ê¸´ ì˜ì† 컨í…ìŠ¤íŠ¸ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì€ 최ìƒì˜ ê°€ìš©ì„±ì„ ìœ„í•´ 가능한 í•œ 짧아야 한다. 하지만 장기간 실행ë˜ëŠ” <emphasis>어플리케ì´ì…˜ 트랜ìžì…˜ë“¤</emphasis>, 사용ìžì˜ ë·° ê´€ì ì—ì„œ í•œ ê°œì˜ ë‹¨ìœ„ ìž‘ì—…ì„ êµ¬í˜„í•˜ëŠ” ê²ƒì´ ê°€ë” í•„ìˆ˜ì ì´ë‹¤. í•˜ë‚˜ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ 트랜ìžì…˜ì€ 몇 ê°œì˜ í´ë¼ì´ì–¸íŠ¸ ìš”ì²ë“¤ê³¼ ì‘답 ì£¼ê¸°ë“¤ì— ê±¸ì¹ ìˆ˜ë„ ìžˆë‹¤. 어플리케ì´ì…˜ 트랜ìžì…˜ë“¤ì„ êµ¬í˜„í•˜ëŠ”ë° detached ê°ì²´ë“¤ì„ 사용하는 ê²ƒì´ ê³µí†µì ì´ë‹¤. 2-í‹°ì–´ 아키í…처ì—ì„œ 매우 ì ì ˆí•œ ëŒ€ì•ˆì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ 트랜ìžì…˜ì˜ ì „ì²´ ìƒëª…주기 ë™ì•ˆì— í•œ ê°œì˜ ì—´ë ¤ì§„ ì˜ì† ì ‘ì† (세션)ì„ ìœ ì§€í•˜ëŠ” 것ì´ê³ ê°ê°ì˜ ìš”ì²ì˜ ëì—ì„œ JDBC ì»¤ë„¥ì…˜ì„ ê°„ë‹¨í•˜ê²Œ ì—°ê²°í•´ì œí•˜ê³ ì°¨í›„ì˜ ìš”ì²ì˜ 시작 ì‹œì— ë‹¤ì‹œ 연결하는 것ì´ë‹¤. í•œ ê°œ ì´ìƒì˜ 어플리케ì´ì…˜ 트랜ìžì…˜ì„ 가로질러서 í•˜ë‚˜ì˜ ë‹¨ì¼ ì„¸ì…˜ì„ ê²°ì½” ê³µìœ í•˜ì!
§€ ë§ë¼. ê³µìœ í• ê²½ìš°ì— ë‹¹ì‹ ì€ ì‹¤íš¨ì„±ì´ ì—†ëŠ” ë°ì´í„°ë¡œ 작업하게 ë 것ì´ë‹¤."
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr "예외ìƒí™©ë“¤ì„ 복구가능한 것으로서 다루지 ë§ë¼."
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr "ì´ê²ƒì€ \"최ìƒì˜\" ì‹¤ì „ì´ ì•„ë‹Œ 보다 필수ì ì¸ ì‹¤ì „ì´ë‹¤. 예외ìƒí™©ì´ ë°œìƒí• ë•Œ, <literal>Transaction</literal>ì„ ë¡¤ë°±ì‹œí‚¤ê³ <literal>Session</literal>ì„ ë‹«ì•„ë¼. ë§Œì¼ ë‹¹ì‹ ì´ ê·¸ë ‡ê²Œ 하지 ì•Šì„ ê²½ìš°, Hibernate는 메모리 ë‚´ ìƒíƒœê°€ ì˜ì† ìƒíƒœë¥¼ ì •í™•í•˜ê²Œ 표현하는 ê²ƒì„ ë³´ì¦í• 수 없다. ì´ íŠ¹ë³„í•œ 경우처럼, ë§Œì¼ ì£¼ì–´ì§„ ì‹ë³„ìžë¥¼ 가진 ì¸ìŠ¤í„´ìŠ¤ê°€ ë°ì´í„°ë² ì´ìŠ¤ ìƒì— 존재하는지 여부를 ê²°ì •í•˜ëŠ”ë° <literal>Session.load()</literal>를 사용하지 ë§ë¼; ëŒ€ì‹ ì— <literal>Session.get()</literal> ë˜ëŠ” í•˜ë‚˜ì˜ ì§ˆì˜ë¥¼ 사용하ë¼."
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr "ì—°ê´€ë“¤ì— ëŒ€í•œ lazy 페ì¹ì„ ì„ í˜¸í•˜ë¼."
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr "eager 페ì¹ì„ 관대하게 사용하ë¼. second-level ìºì‹œ ë‚´ì— ì™„ì „í•˜ê²Œ ë³´ê´€ë˜ì§€ ì•Šì„ ê²ƒ ê°™ì€ í´ëž˜ìŠ¤ë“¤ì— 대한 ëŒ€ë¶‘ë¶„ì˜ ì—°ê´€ë“¤ì— ëŒ€í•´ 프ë½ì‹œë“¤ê³¼ lazy ì½œë ‰ì…˜ë“¤ì„ ì‚¬ìš©í•˜ë¼. ìºì‹œëœ í´ëž˜ìŠ¤ë“¤ì— 대한 ì—°ê´€ë“¤ì˜ ê²½ìš°, ì´ê³³ì€ ìºì‹œ ì„±ê³µì˜ ë§¤ìš° ë†’ì€ í™•ë¥ ì´ ì¡´ìž¬í•˜ëŠ” ê³³ì´ë©°, <literal>lazy=\"false\"</literal>를 사용하여 eager 페ì¹ì„ 명시ì 으로 사용 불가능하게 하ë¼. í•œì˜ join 페ì¹ì´ íŠ¹ì • ì“°ìž„ìƒˆì— ëŒ€í•´ ì ì ˆí• ë•Œ, í•˜ë‚˜ì˜ <literal>left join fetch</literal>를 가진 질ì˜ë¥¼ 사용하ë¼."
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr "페치ë˜ì§€ ì•Šì€ ë°ì´í„° ë¬¸ì œì ë“¤ì„ í”¼í•˜ê¸° 위해 <emphasis>ë·° ë‚´ì— ì—´ë ¤ì§„ 세션(open session in view)</emphasis> 패턴 ë˜ëŠ” í•˜ë‚˜ì˜ ì •ë¦¬ëœ <emphasis>어셈블리 단계(assembly phase)</emphasis>를 사용하ë¼."
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr "Hibernate는 개발ìžë“¤ì´ <emphasis>Data Transfer Objects</emphasis> (DTO)를 지루하게 작성하는 것으로부터 ìžìœ ë¡ê²Œ 해준다. ì „í†µì ì¸ EJB 아키í…처ì—ì„œ, DTO는 ì´ì¤‘ ìš©ë„ë¡œ 기능한다: 첫 번째로 ê·¸ê²ƒë“¤ì€ ì—”í‹°í‹° 빈즈가 ì§ë ¬í™” 가능하지 않는 ë¬¸ì œì ì— ëŒ€í•´ 착수한다; ë‘ ë²ˆì§¸ë¡œ ê·¸ê²ƒë“¤ì€ ë·°ì— ì˜í•´ 사용ë˜ëŠ” ëª¨ë“ ë°ì´í„°ê°€ 프리ì í…Œì´ì…˜ í‹°ì–´ë¡œ ì»¨íŠ¸ë¡¤ì„ ë°˜í™˜í•˜ê¸° ì „ì— DTO들 ì†ìœ¼ë¡œ 페치ë˜ê³ 마샬ë§ë˜ëŠ” 어셈블리 단계를 암묵ì 으로 ì •ì˜í•œë‹¤. Hibernate는 첫 번째 ìš©ë„를 ì œê±°ì‹œí‚¨ë‹¤. 하지만 ë‹¹ì‹ ì´ ë·° ë Œë”ë§ í”„ë¡œì„¸ìŠ¤ë¥¼ 가로질러 ì—´ë ¤ì ¸ 있는 ì˜ì† 컨í…스트(세션)ì„ ë³´ê´€í• ì¤€ë¹„ê°€ ë˜ì–´ 있지 않는 í•œ, ë‹¹ì‹ ì€ ì—¬ì „ížˆ 어셈블리 단계를 필요로 í• ê²ƒì´ë‹¤(detached ê°ì²´ë“¤ì—ì„œ ì´ìš©ê°€ëŠ¥í•œ ë°ì´í„°ê°€ 무엇ì¸ì§€ì— 대해 프리ì í…Œì´ì…˜ 티어와 엄격하게 ê³„ì•½ì„ ê°–ë„ë¡!
ë‹¹ì‹ ì˜ ë¹„ì§€ë‹ˆìŠ¤ ë©”ì†Œë“œë“¤ì„ ê³ ë ¤í•˜ë¼) ì´ê²ƒì€ Hibernateì˜ í•œê³„ì ì´ ì•„ë‹ˆë‹¤! ê·¸ê²ƒì€ ì•ˆì „í•œ 트랜ìžì…˜ ë°ì´í„° ì ‘ê·¼ì˜ í•„ìˆ˜ ì¡°ê±´ì´ë‹¤."
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr "Hibernateì—ì„œ ë‹¹ì‹ ì˜ ë¹„ì§€ë‹ˆìŠ¤ ë¡œì§ì„ 추ìƒí™” 시키는 ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr "(Hibernate) ë°ì´í„° 액세스 코드를 ì¸í„°íŽ˜ì´ìŠ¤ ì´ë©´ì— ì€í시켜ë¼. <emphasis>DAO</emphasis>와 <emphasis>Thread Local Session</emphasis> íŒ¨í„´ë“¤ì„ ê²°í•©ì‹œì¼œë¼. ë‹¹ì‹ ì€ ì‹¬ì§€ì–´ <literal>UserType</literal>ì„ í†µí•´ Hibernateì— ì—°ê´€ëœ, 수작업으로 ì½”ë”©ëœ JDBC로서 몇몇 í´ëž˜ìŠ¤ë“¤ì„ ì˜ì†í™” 시킬 ìˆ˜ë„ ìžˆë‹¤. (ì´ ì¶©ê³ ëŠ” \"충분히 í°\" 어플리케ì´ì…˜ë“¤ì— 대한 것ì´ë‹¤; ê·¸ê²ƒì€ 5ê°œì˜ í…Œì´ë¸”ë“¤ì„ ê°€ì§„ 어플리케ì´ì…˜ì— 대해서는 ì ì ˆí•˜ì§€ 않다!)"
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr "ì‹ ì¢…ì˜ ì—°ê´€ ë§¤í•‘ì„ ì‚¬ìš©í•˜ì§€ ë§ë¼."
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr "ì‹¤ì œì˜ many-to-many ì—°ê´€ë“¤ì— ëŒ€í•œ ì¢‹ì€ ì“°ìž„ìƒˆë“¤ì€ ë“œë¬¼ë‹¤. ëŒ€ë¶€ë¶„ì˜ ì‹œê°„ ë™ì•ˆ ë‹¹ì‹ ì€ \"ì—°ê²° í…Œì´ë¸”\" ë‚´ì— ì €ìž¥ëœ ì¶”ê°€ì ì¸ ì •ë³´ë¥¼ 필요로 한다. ì´ ê²½ìš°ì—, 매개하는 ì—°ê²° í´ëž˜ìŠ¤ì— 대해 ë‘ ê°œì˜ one-to-many ì—°ê´€ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì´ í›¨ì”¬ ë” ì¢‹ë‹¤. 사실 우리는 ëŒ€ë¶€ë¶„ì˜ ì—°ê´€ë“¤ì´ one-to-many와 many-to-oneì´ë¼ê³ ìƒê°í•˜ë©°, ë‹¹ì‹ ì€ ë‹¤ë¥¸ ì—°ê´€ 스타ì¼ì„ ì‚¬ìš©í• ë•Œ 주ì˜í•´ì•¼ í•˜ê³ ê·¸ê²ƒì´ ì§„ì • 필수ì ì¸ì§€ë¥¼ ë‹¹ì‹ ìŠ¤ìŠ¤ë¡œ 질문하ë¼."
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr "ì–‘ë°©í–¥ ì—°ê´€ë“¤ì„ ì„ í˜¸í•˜ë¼."
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr "단방향 ì—°ê´€ë“¤ì€ ì§ˆì˜í•˜ê¸°ê°€ ë” ì–´ë µë‹¤. ë§Žì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—ì„œ, ê±°ì˜ ëª¨ë“ ì—°ê´€ë“¤ì€ ì§ˆì˜ë“¤ ë‚´ì—ì„œ ì–‘ 방향으로 네비게ì´íŠ¸ 가능해야 한다."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1287 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr "ì½œë ‰ì…˜ 매핑"
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr "ì˜ì† ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr "예를 들어 Hibernate는 ì˜ì† ì½œë ‰ì…˜-ê°’ì„ ê°€ì§„ í•„ë“œë“¤ì´ ì¸í„°íŽ˜ì´ìŠ¤ 타입으로서 ì„ ì–¸ë ê²ƒì„ í•„ìš”ë¡œ 한다:"
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr "ì‹¤ì œ ì¸í„°íŽ˜ì´ìŠ¤ëŠ” <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> ë˜ëŠ” ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ì–´ë–¤ ê²ƒì¼ ìˆ˜ 있다!(여기서 \"ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ì–´ë–¤ 것\"ì´ëž€ ë‹¹ì‹ ì´ <literal>org.hibernate.usertype.UserCollectionType</literal>ì— ëŒ€í•œ êµ¬í˜„ì„ ìž‘ì„±í•´ì•¼ í•¨ì„ ì˜ë¯¸í•œë‹¤.)"
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr "우리가 <literal>HashSet</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 가진 ì¸ìŠ¤í„´ìŠ¤ 변수를 초기화 ì‹œì¼°ë˜ ë°©ë²•ì„ ì£¼ëª©í•˜ë¼. ì´ê²ƒì€ ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ(비-ì˜ì†) ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 가진 ì½œë ‰ì…˜ ê°’ 프로í¼í‹°ë“¤ì„ 초기화 시키는 ìµœì„ ì˜ ë°©ë²•ì´ë‹¤. ë‹¹ì‹ ì´ -예를 들어 <literal>persist()</literal>를 호출하여- ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì˜ì†í™” 시킬 ë•Œ Hibernate는 ì‹¤ì œë¡œ <literal>HashSet</literal>ì„ <literal>Set</literal>ì— ëŒ€í•œ Hibernate ìžì‹ ì˜ êµ¬í˜„ì˜ ì¸ìŠ¤í„´ìŠ¤ë¡œ 대체시킬 것ì´ë‹¤. 다ìŒê³¼ ê°™ì€ ì˜¤ë¥˜ë“¤ì„ ê´€ì°°í•˜ë¼:"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr "Hibernateì— ì˜í•´ ë„ìž…ëœ ì˜ì† ì½œë ‰ì…˜ë“¤ì€ ì¸í„°íŽ˜ì´ìŠ¤ íƒ€ìž…ì— ë”°ë¼ <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> ë˜ëŠ” <literal>ArrayList</literal>와 ê°™ì´ í–‰ìœ„í•œë‹¤."
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr "ì½œë ‰ì…˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ value íƒ€ìž…ë“¤ì„ ê°€ì§„ 통ìƒì˜ íŠ¹ì§•ì„ ê°–ëŠ”ë‹¤. ê·¸ê²ƒë“¤ì€ ì˜ì† ê°ì²´ì— ì˜í•´ 참조ë ë•Œ ìžë™ì 으로 ì˜ì†í™” ë˜ê³ 참조 í•´ì œë ë•Œ ìžë™ì 으로 ì‚ì œëœë‹¤. ë§Œì¼ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì´ í•˜ë‚˜ì˜ ì˜ì† ê°ì²´ë¡œë¶€í„° ë˜ ë‹¤ë¥¸ ì˜ì† ê°ì²´ë¡œ ì „ë‹¬ë ë•Œ, ê·¸ê²ƒì˜ ìš”ì†Œë“¤ì€ í•˜ë‚˜ì˜ í…Œì´ë¸”로부터 다른 í…Œì´ë¸”ë¡œ ì´ë™ë 수 있다. ë‘ ê°œì˜ ì—”í‹°í‹°ë“¤ì€ ë™ì¼í•œ ì½œë ‰ì…˜ ì¸ìŠ¤í„´ìŠ¤ì— 대한 참조를 ê³µìœ í•˜ì§€ 않는다. 기본 관계형 모형 ë•Œë¬¸ì— ì½œë ‰ì…˜ ê°’ 프로í¼í‹°ë“¤ì€ null ê°’ ì˜ë¯¸ë“¤ì„ 지ì›í•˜ì§€ 않는다; Hibernate는 null ì½œë ‰ì…˜ 참조와 ê³µë°±ì˜ ì½œë ‰ì…˜ 사ì´ë¥¼ 구별 짓지 않는다."
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr "ë‹¹ì‹ ì€ ì´ê²ƒì˜ ì–´ë–¤ ê²ƒì— ëŒ€í•´ 너무 ë§Žì´ ê±±ì •í•˜ì§€ ì•Šì•„ë„ ë 것ì´ë‹¤. ë‹¹ì‹ ì´ í†µìƒì˜ ìžë°” ì½œë ‰ì…˜ë“¤ì„ ì‚¬ìš©í•˜ëŠ” 것과 ë™ì¼í•œ 방법으로 ì˜ì† ì½œë ‰ì…˜ë“¤ì„ ì‚¬ìš©í•˜ë¼. 단지 ë‹¹ì‹ ì´ ì–‘ë°©í–¥ ì—°ê´€ê´€ê³„ë“¤ì— ëŒ€í•œ ì˜ë¯¸ë¥¼ 확실히 ì´í•´í•˜ë„ë¡ í•˜ë¼(ë‚˜ì¤‘ì— ë…¼ì˜ë¨)."
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr "ì½œë ‰ì…˜ 매핑들"
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr "ì½œë ‰ì…˜ì„ ë§¤í•‘í•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” Hiberante 매핑 요소는 ì¸í„°íŽ˜ì´ìŠ¤ì˜ íƒ€ìž…ì— ì˜ì¡´í•œë‹¤. 예를 들어<literal><set></literal> 요소는 <literal>Set</literal> íƒ€ìž…ì˜ ë§¤í•‘ 프로í¼í‹°ë“¤ì— 사용ëœë‹¤"
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr "<literal><set></literal>과는 별ë„ë¡œ, ë˜í•œ <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal>, ê·¸ë¦¬ê³ <literal><map></literal> 매핑 ìš”ì†Œë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal><map></literal> 요소가 대표ì ì´ë‹¤:"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr "<literal>name</literal> ì½œë ‰ì…˜ 프로í¼í‹° ì´ë¦„"
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr "<literal>table</literal> (옵션 - ë””í´íŠ¸ëŠ” 프로í¼í‹° ì´ë¦„) ì½œë ‰ì…˜ í…Œì´ë¸”ì˜ ì´ë¦„(one-to-many ì—°ê´€ê´€ê³„ë“¤ì— ëŒ€í•´ì„œëŠ” 사용ë˜ì§€ ì•ŠìŒ)"
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr "<literal>schema</literal> (옵션) 루트 요소 ìƒì— ì„ ì–¸ëœ ìŠ¤í‚¤ë§ˆë¥¼ 오버ë¼ì´ë“œ 시키는 í…Œì´ë¸” ìŠ¤í‚¤ë§ˆì˜ ì´ë¦„"
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr "<literal>lazy</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>)는 lazy 페ì¹ì„ 사용 불가능하ë„ë¡ í•˜ê³ ê·¸ ì—°ê´€ì´ í•ìƒ eagerly 페치ë¨ì„ ì§€ì •í•˜ëŠ”ë° , ë˜ëŠ” ëŒ€ë¶€ë¶„ì˜ ì—°ì‚°ë“¤ì´ ì½œë ‰ì…˜ì„ ì´ˆê¸°í™”ì‹œí‚¤ì§€ 않는 ê³³ì—ì„œ \"extra-lazy\" 페ì¹ì„ ì´ìš© 가능하ë„ë¡ í•˜ëŠ”ë°(매우 í° ì½œë ‰ì…˜ë“¤ì— ì 당함) 사용ë 수 있다"
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr "<literal>inverse</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>false</literal>) ì´ ì½œë ‰ì…˜ì„ ì–‘ë°©í–¥ ì—°ê´€ê´€ê³„ì˜ \"inverse\" ë(end)으로 표시한다"
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr "<literal>cascade</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>none</literal>) 오í¼ë ˆì´ì…˜ë“¤ì´ ìžì‹ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ 케스케ì´ë“œí•˜ëŠ” ê²ƒì„ ì´ìš© 가능하게 한다"
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr "<literal>sort</literal> (옵션) <literal>natural</literal> ì •ë ¬ 순서로 ì •ë ¬ëœ(sorted) ì½œë ‰ì…˜ ë˜ëŠ” 주어진 comparator í´ëž˜ìŠ¤ë¥¼ ì§€ì •í•œë‹¤"
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr "<literal>order-by</literal> (옵션, JDK1.4ì—서만) <literal>asc</literal> ë˜ëŠ” <literal>desc</literal> 옵션과 함께 <literal>Map</literal>, <literal>Set</literal> ë˜ëŠ” bagì˜ ë°˜ë³µ 순서를 ì •ì˜í•˜ëŠ” í…Œì´ë¸” 컬럼(ë˜ëŠ” 컬럼들)ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr "<literal>where</literal> (옵션) ì½œë ‰ì…˜ì„ ê²€ìƒ‰í•˜ê±°ë‚˜ ì œê±°í• ë•Œ 사용ë ìž„ì˜ì ì¸ SQL <literal>WHERE</literal> ì¡°ê±´ì„ ì§€ì •í•œë‹¤ (ì½œë ‰ì…˜ì´ ì˜¤ì§ ì´ìš© 가능한 ë°ì´í„°ì˜ 부분집합 ë§Œì„ í¬í•¨í• ê²½ìš°ì— ìœ ìš©í•˜ë‹¤)"
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr "<literal>fetch</literal> (옵션, ë””í´íŠ¸ëŠ” <literal>select</literal>) outer-join 페ì¹, sequential select 페ì¹, ê·¸ë¦¬ê³ sequential subselect íŽ˜ì¹ ì‚¬ì´ì—ì„œ ì„ íƒí•˜ë¼."
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr "<literal>batch-size</literal> (옵션, ë””í´íŠ¸ëŠ” <literal>1</literal>) ì´ ì½œë ‰ì…˜ì˜ lazily fetching ì¸ìŠ¤í„´ìŠ¤ì— 대해 \"배치 사ì´ì¦ˆ\"를 ì§€ì •í•˜ë¼."
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr "<literal>access</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>property</literal>): Hibernateê°€ ì½œë ‰ì…˜ 프로í¼í‹° ê°’ì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©í• ë°©ë„."
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr "<literal>optimistic-lock</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): ì½œë ‰ì…˜ì˜ ìƒíƒœì— 대한 ë³€ê²½ë“¤ì´ ì†Œìœ í•˜ëŠ” ì—”í‹°í‹°ì˜ ë²„ì „ì˜ ì¦ê°€ë¡œ 귀결ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤. (one to many ì—°ê´€ë“¤ì— ëŒ€í•´, ì´ ì„¤ì •ì„ ì‚¬ìš© 불가능하게 하는 ê²ƒì´ ì¢…ì¢… 합당하다.)"
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr "<literal>mutable</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>true</literal>): <literal>false</literal> ê°’ì€ ì½œë ‰ì…˜ì˜ ìš”ì†Œë“¤ì´ ê²°ì½” 변경ë˜ì§€ ì•ŠìŒì„ ì§€ì •í•œë‹¤. (몇몇 경우들ì—ì„œ 마ì´ë„ˆ í¼í¬ë¨¼ìŠ¤ 최ì í™”)."
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr "ì½œë ‰ì…˜ foreign 키들"
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr "ì½œë ‰ì…˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ê·¸ ì½œë ‰ì…˜ì„ ì†Œìœ í•˜ëŠ” ì—”í‹°í‹°ì˜ foreign í‚¤ì— ì˜í•´ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ 구별지워진다. ì´ foreign 키는 ê·¸ ì½œë ‰ì…˜ í…Œì´ë¸”ì˜ <emphasis>ì½œë ‰ì…˜ 키 컬럼</emphasis> (ë˜ëŠ” 컬럼들)로서 참조ëœë‹¤. ê·¸ ì½œë ‰ì…˜ 키 ì»¬ëŸ¼ì€ <literal><key></literal> ìš”ì†Œì— ì˜í•´ 매핑ëœë‹¤."
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr "foreign 키 ì»¬ëŸ¼ì— ëŒ€í•œ null 허용 가능 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ê°€ ì¡´ìž¬í• ìˆ˜ 있다. ëŒ€ë¶€ë¶„ì˜ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´, ì´ê²ƒì´ 당연히 수반ëœë‹¤. 단방향 one to many ì—°ê´€ë“¤ì˜ ê²½ìš°, foreign 키는 ë””í´íŠ¸ë¡œ null 허용 가능하여서, ë‹¹ì‹ ì€ <literal>not-null=\"true\"</literal>를 ì§€ì •í• í•„ìš”ê°€ ìžˆì„ ìˆ˜ 있다."
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr "foreign 키 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ëŠ” <literal>ON DELETE CASCADE</literal>를 ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr "<literal><key></literal> ìš”ì†Œì— ëŒ€í•œ ì „ì²´ ì •ì˜ëŠ” ì•ž ìž¥ì„ ë³´ë¼."
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr "ì½œë ‰ì…˜ 요소들"
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr "ì½œë ‰ì…˜ë“¤ì€ ëª¨ë“ ê¸°ë³¸ 타입들, ì»´í¬ë„ŒíŠ¸ë“¤, ê·¸ë¦¬ê³ ë¬¼ë¡ ë‹¤ë¥¸ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ ì°¸ì¡°ë“¤ì„ í¬í•¨í•˜ì—¬ ê±°ì˜ ëŒ€ë¶€ë¶„ì˜ ì–´ë–¤ 다른 Hibernate íƒ€ìž…ì„ í¬í•¨í• ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ 중요한 구분ì´ë‹¤: ì½œë ‰ì…˜ ë‚´ì— ìžˆëŠ” ê°ì²´ëŠ” \"ê°’(value)\" ì˜ë¯¸ë¡œ 처리ë ìˆ˜ë„ ìžˆê±°ë‚˜(ê·¸ê²ƒì˜ ìƒëª…주기는 ì½œë ‰ì…˜ ì†Œìœ ìžì— ì˜ì¡´í•œë‹¤) ê·¸ê²ƒì€ ê·¸ê²ƒ ìžì‹ ì˜ ìƒëª…주기를 가진 ë˜ ë‹¤ë¥¸ ì—”í‹°í‹°ì— ëŒ€í•œ ì°¸ì¡°ì¼ ìˆ˜ 있다. 후ìžì˜ 경우, ë‘ ê°œì˜ ê°ì²´ë“¤ 사ì´ì˜ \"ë§í¬\" ë§Œì´ ê·¸ ì½œë ‰ì…˜ì— ì˜í•´ ì†Œìœ ëœ ìƒíƒœë¡œ 간주ëœë‹¤."
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr "í¬í•¨ëœ íƒ€ìž…ì€ ì½œë ‰ì…˜ 요소 타입으로서 ë¶ˆë ¤ì§„ë‹¤. ì½œë ‰ì…˜ ìš”ì†Œë“¤ì€ <literal><element></literal> ë˜ëŠ” <literal><composite-element></literal>ì— ì˜í•´ 매핑ë˜ê±°ë‚˜, 엔티티 ì°¸ì¡°ë“¤ì˜ ê²½ìš°ì— <literal><one-to-many></literal> ë˜ëŠ” <literal><many-to-many></literal>로서 매핑ëœë‹¤. ì•žì˜ ë‘ ê°œëŠ” value ì˜ë¯¸ë¥¼ 가진 ìš”ì†Œë“¤ì„ ë§¤í•‘ì‹œí‚¤ê³ , ë’¤ì˜ ë‘개는 엔티티 ì—°ê´€ë“¤ì„ ë§¤í•‘í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr "ì¸ë±ì‹± ëœ ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr "set ê³¼ bag ì˜ë¯¸ë“¤ì„ 가진 ê²ƒë“¤ì„ ì œì™¸í•˜ë©´, ëª¨ë“ ì½œë ‰ì…˜ ë§¤í•‘ë“¤ì€ ì½œë ‰ì…˜ í…Œì´ë¸” ë‚´ì— <emphasis>ì¸ë±ìŠ¤ 컬럼</emphasis>- ë°°ì—´ ì¸ë±ìŠ¤, ë˜ëŠ” <literal>List</literal> ì¸ë±ìŠ¤ ë˜ëŠ” <literal>Map</literal> 키로 매핑ë˜ëŠ” 컬럼-ì„ í•„ìš”ë¡œ 한다. <literal>Map</literal>ì˜ ì¸ë±ìŠ¤ëŠ” <literal><map-key></literal>ë¡œ 매핑ëœ, ì–´ë–¤ 기본 íƒ€ìž…ì¼ ìˆ˜ ìžˆê³ , ê·¸ê²ƒì€ <literal><map-key-many-to-many></literal>ë¡œ ë§¤í•‘ëœ ì—”í‹°í‹° ì°¸ì¡°ì¼ ìˆ˜ 있거나, ê·¸ê²ƒì€ <literal><composite-map-key></literal>ë¡œ ë§¤í•‘ëœ composite íƒ€ìž…ì¼ ìˆ˜ 있다. ë°°ì—´ ë˜ëŠ” ë¦¬ìŠ¤íŠ¸ì˜ ì¸ë±ìŠ¤ëŠ” í•ìƒ <literal>integer</literal> 타입ì´ê³ <literal><list-index></literal> 요소를 사용하여 매핑ëœë‹¤. ë§¤í•‘ëœ ì»¬ëŸ¼ì€ ìˆœì°¨ì ì¸ ì •ìˆ˜ë“¤ì„ í¬í•¨í•œë‹¤(ë””í´íŠ¸ë¡œ 0ì—ì„œ 시작하는 번호가 붙여ì§)."
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (필수): ì½œë ‰ì…˜ ì¸ë±ìŠ¤ ê°’ë“¤ì„ ë³´ê´€í•˜ëŠ” ì»¬ëŸ¼ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (옵션, ë””í´íŠ¸ëŠ” <literal>0</literal>): 리스트 ë˜ëŠ” ë°°ì—´ì˜ ì²« 번째 ìš”ì†Œì— ëŒ€ì‘하는 ì¸ë±ìŠ¤ ì»¬ëŸ¼ì˜ ê°’. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (옵션): ì½œë ‰ì…˜ ì¸ë±ìŠ¤ ê°’ë“¤ì„ ë³´ê´€í•˜ëŠ” ì»¬ëŸ¼ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (옵션): mapì˜ í‚¤ë¥¼ í‰ê°€í•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” SQL formula. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (필수): The type of the map í‚¤ë“¤ì˜ íƒ€ìž… </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (옵션): ì½œë ‰ì…˜ ì¸ë±ìŠ¤ ê°’ë“¤ì— ëŒ€í•œ foreign 키 ì»¬ëŸ¼ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (옵션): mapì˜ foreign 키를 í‰ê°€í•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” SQL formula. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (필수): map 키로서 사용ë˜ëŠ” 엔티티 í´ëž˜ìŠ¤. </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ í…Œì´ë¸”ì´ ì¸ë±ìŠ¤ ì»¬ëŸ¼ì„ ê°€ì§€ ì•Šê³ , ë‹¹ì‹ ì´ ì—¬ì „ížˆ 프로í¼í‹° 타입으로서 <literal>List</literal>를 ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ ê·¸ 프로í¼í‹°ë¥¼ Hibernate <emphasis><bag></emphasis>으로서 매핑해야 한다. bagì´ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° 검색ë ë•Œ ê·¸ê²ƒì€ ê·¸ê²ƒì˜ ìˆœì„œë¥¼ ë³´ìœ í•˜ì§€ 않지만, ê·¸ê²ƒì€ ì„ íƒì 으로 ì •ë ¬(sorting)ë˜ê±°ë‚˜ orderingë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr "ë§Žì€ ê³µí†µëœ ê´€ê³„í˜• ëª¨í˜•ë“¤ì„ ë‹¤ë£¨ëŠ”, ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ ìƒì„±ë 수 있는 ë§¤í•‘ë“¤ì˜ ì˜ì—ì´ ê½¤ 존재한다. 여러가지 매핑 ì„ ì–¸ë“¤ì´ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”들로 변환ë˜ëŠ” ë°©ë²•ì„ ë‹¹ì‹ ì´ ëŠë¼ë ¤ë©´ 스키마 ìƒì„± ë„구로 ì‹¤í—˜í• ê²ƒì„ ìš°ë¦¬ëŠ” ì œì•ˆí•œë‹¤."
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr "ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ê³¼ many-to-many 연관들"
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr "ì–´ë–¤ ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ ë˜ëŠ” many-to-many ì—°ê´€ì€ foreign 키 컬럼ì´ë‚˜ 컬럼들, <emphasis>ì½œë ‰ì…˜ 요소 컬럼</emphasis>ì´ë‚˜ 컬럼들 ê·¸ë¦¬ê³ ê°€ëŠ¥í•˜ë©´ ì¸ë±ìŠ¤ 컬럼들ì´ë‚˜ ì»¬ëŸ¼ë“¤ì„ ê°€ì§„ ì „ìš© <emphasis>ì½œë ‰ì…˜ í…Œì´ë¸”</emphasis>ì„ í•„ìš”ë¡œ 한다."
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr "ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì˜ ê²½ìš°, 우리는 <literal><element></literal> 태그를 사용한다."
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (옵션): ì½œë ‰ì…˜ 요소 ê°’ë“¤ì„ ì†Œìœ í•˜ëŠ” ì»¬ëŸ¼ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (옵션): 요소를 í‰ê°€í•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” SQL formula. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (필수): ì½œë ‰ì…˜ ìš”ì†Œì˜ íƒ€ìž…. </para> </callout> </calloutlist> </programlistingco> <para> <emphasis>many-to-many association</emphasis> ì—°ê´€ì€ <literal><many-to-many></literal> 요소를 사용하여 ì§€ì •ëœë‹¤. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id!
=\"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (옵션): 요소 foreign 키 ì»¬ëŸ¼ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (옵션): 요소 foreign 키 ê°’ì„ í‰ê°€í•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” SQL formula. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (필수): ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ ì´ë¦„. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>join</literal>): ì´ ì—°ê´€ì— ëŒ€í•´ outer-join íŽ˜ì¹ ë˜ëŠ” sequential select 페ì¹ì„ ì´ìš© 가능하게 ë§Œë“ ë‹¤. ì´ê²ƒì€ 특별한 경우ì´ë‹¤; 엔티티 ê·¸ë¦¬ê³ ë‹¤ë¥¸ 엔티티들과 ê·¸ê²ƒì˜ many-to-many ê´€ê³„ë“¤ì— ëŒ€í•œ (í•˜ë‚˜ì˜ <literal>SELECT</literal> ë‚´ì—ì„œ) ì „ì²´ eager 페ì¹ì˜ 경우, ë‹¹ì‹ ì€ ì½œë ‰ì…˜ ê·¸ ìžì²´ì— 대해서 ë¿ë§Œ ì•„ë‹ˆë¼ ë‚´í¬ëœ 요소 <literal><ma!
ny-to-many></literal> ìƒì˜ ì´ ì†ì„±ì— 대해 <literal>join</literal> 페ì¹ì„ ì´ìš© 가능하게 í• ê²ƒì´ë‹¤. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (옵션): foreign-key ì»¬ëŸ¼ì— ëŒ€í•œ ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ DDL ìƒì„±ì„ 가능하ë„ë¡ í•œë‹¤. ì´ê²ƒì€ ì—°ê´€ 다중성 (association multiplicity)ì„ íš¨ìœ¨ì 으로 one to manyë¡œ ë§Œë“ ë‹¤. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>exception</literal>): 누ë½ëœ í–‰ë“¤ì„ ì°¸ì¡°í•˜ëŠ” foreign í‚¤ë“¤ì´ ì–´ë–»ê²Œ 처리ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤: <literal>ignore</literal>는 누ë½ëœ í•œ í–‰ì„ í•œ ê°œì˜ ì—°ê´€ìœ¼ë¡œ 다룰 것ì´ë‹¤. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (옵션): <literal>class</literal>ì— ëŒ€í•œ í•˜ë‚˜ì˜ ëŒ€ì•ˆìœ¼ë¡œì„œ, ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ 엔티티 ì´ë¦„. </para> </callout> <callout arearef!
s=\"manytomany8\"> <para> <literal>property-ref</literal>: (옵션) ì
´ foreign í‚¤ì— ì¡°ì¸ëœ ì—°ê´€ í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ì˜ ì´ë¦„. ì§€ì •ë˜ì§€ ì•Šì„ ê²½ìš°, ì—°ê´€ í´ëž˜ìŠ¤ì˜ 프ë¼ì´ë¨¸ë¦¬ 키가 사용ëœë‹¤. </para> </callout> </calloutlist> </programlistingco>"
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr "몇몇 ì˜ˆì œë“¤, ë¨¼ì € 문ìžì—´ë“¤ì„ 가진 set:"
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr "(<literal>order-by</literal> ì†ì„±ì— ì˜í•´ ê²°ì •ë˜ëŠ” 반복 순서를 가진) ì •ìˆ˜ë“¤ì„ í¬í•¨í•˜ëŠ” bag :"
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr "ì—”í‹°í‹°ë“¤ì„ ê°€ì§„ ë°°ì—´ - ì´ ê²½ìš°ì—, many to many ì—°ê´€ :"
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr "ë‚ ì§œë“¤ì— ëŒ€í•œ 문ìžì—´ ì¸ë±ìŠ¤ë“¤ì„ 가진 map :"
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤ì˜ 리스트(ë‹¤ìŒ ìž¥ì—ì„œ ë…¼ì˜ë¨):"
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr "One-to-many 연관들"
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr "<emphasis>one to many ì—°ê´€</emphasis>ì€ ì¤‘ìž¬í•˜ëŠ” ì½œë ‰ì…˜ í…Œì´ë¸” ì—†ì´ foreign 키를 통해 ë‘ ê°œì˜ í´ëž˜ìŠ¤ë“¤ì˜ í…Œì´ë¸”ë“¤ì„ ì—°ê²°ì‹œí‚¨ë‹¤. ì´ ë§¤í•‘ì€ í†µìƒì˜ ìžë°” ì½œë ‰ì…˜ë“¤ì˜ ì–´ë–¤ ì˜ë¯¸ë¥¼ ìƒì‹¤í•œë‹¤:"
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr "í¬í•¨ëœ 엔티티 í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” ê·¸ ì½œë ‰ì…˜ì˜ í•˜ë‚˜ ì´ìƒì˜ ì¸ìŠ¤í„´ìŠ¤ì— ì†í•˜ì§€ ì•Šì„ ìˆ˜ 있다"
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr "í¬í•¨ëœ 엔티티 í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” ì½œë ‰ì…˜ ì¸ë±ìŠ¤ì˜ 하나 ì´ìƒì˜ ê°’ì—ì„œ 나타나지 ì•Šì„ ìˆ˜ 있다"
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr "<literal>Product</literal>로부터 <literal>Part</literal>ë¡œì˜ ì—°ê´€ì€ foreign 키 컬럼과 <literal>Part</literal> í…Œì´ë¸”ì— ëŒ€í•œ ì¸ë±ìŠ¤ ì»¬ëŸ¼ì˜ ì¡´ìž¬ë¥¼ 필요로 한다. <literal><one-to-many></literal> 태그는 ì´ê²ƒì´ one to many ì—°ê´€ìž„ì„ ë‚˜íƒ€ë‚¸ë‹¤."
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr "<literal>class</literal> (필수): ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ ì´ë¦„."
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>not-found</literal> (옵션 - ë””í´íŠ¸ëŠ” <literal>exception</literal>): 누ë½ëœ í–‰ë“¤ì„ ì°¸ì¡°í•˜ëŠ” ìºì‹œëœ ì‹ë³„ìžë“¤ì´ 어떻게 처리ë 것ì¸ì§€ë¥¼ ì§€ì •í•œë‹¤: <literal>ignore</literal>는 누ë½ëœ í•œ í–‰ì„ í•œ ê°œì˜ ì—°ê´€ìœ¼ë¡œ 다룰 것ì´ë‹¤."
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr "<literal>entity-name</literal> (옵션): <literal>class</literal>ì— ëŒ€í•œ 대안으로서, ì—°ê´€ëœ í´ëž˜ìŠ¤ì˜ 엔티티 ì´ë¦„."
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr "<literal><one-to-many></literal> 요소는 ì–´ë–¤ ì»¬ëŸ¼ë“¤ì„ ì„ ì–¸í•˜ëŠ”ë° í•„ìš”í•˜ì§€ ì•ŠìŒì„ 주목하ë¼. ì–´ë”˜ê°€ì— <literal>table</literal> ì´ë¦„ì„ ì§€ì •í•˜ëŠ” ê²ƒë„ í•„ìˆ˜ì ì´ì§€ 않다."
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr "<emphasis>매우 중요한 노트</emphasis>: ë§Œì¼ <literal><one-to-many></literal> ì—°ê´€ì˜ foreign 키 ì»¬ëŸ¼ì´ <literal>NOT NULL</literal>ë¡œ ì„ ì–¸ë 경우, ë‹¹ì‹ ì€ <literal><key></literal> ë§¤í•‘ì„ <literal>not-null=\"true\"</literal>ë¡œ ì„ ì–¸í•´ì•¼ 하거나 <literal>inverse=\"true\"</literal>ë¡œ 마í¬ëœ ì½œë ‰ì…˜ ë§¤í•‘ì„ ê°€ì§„ <emphasis>ì–‘ë°©í–¥ ì—°ê´€ì„ ì‚¬ìš©í•´ì•¼ 한다</emphasis>. ì–‘ë°©í–¥ ì—°ê´€ë“¤ì— ëŒ€í•œ ë…¼ì˜ëŠ” ì´ ìž¥ì˜ ë’·ë¶€ë¶„ì„ ë³´ë¼."
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr "ì´ ì˜ˆì œëŠ” name으로 <literal>Part</literal> ì—”í‹°í‹°ë“¤ì„ ê°€ì§„ mapì„ ë³´ì—¬ì¤€ë‹¤(여기서 <literal>partName</literal>ì€ <literal>Part</literal>ì˜ ì˜ì† 프로í¼í‹°ì´ë‹¤). formula-기반 indexì˜ ì‚¬ìš©ì„ ì£¼ëª©í•˜ë¼."
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr "ê°œì„ ëœ ì½œë ‰ì…˜ 매핑들"
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr "Sorted ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr "Hibernate는 <literal>java.util.SortedMap</literal>ê³¼ <literal>java.util.SortedSet</literal>를 구현하는 ì½œë ‰ì…˜ë“¤ì„ ì§€ì›í•œë‹¤. ë‹¹ì‹ ì€ ë§¤í•‘ íŒŒì¼ ì†ì— í•˜ë‚˜ì˜ comparator를 ì§€ì •í•´ì•¼ 한다:"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr "<literal>sort</literal> ì†ì„±ì— 허용ë˜ëŠ” ê°’ë“¤ì€ <literal>unsorted</literal>, <literal>natural</literal>, ê·¸ë¦¬ê³ <literal>java.util.Comparator</literal>를 구현하는 í´ëž˜ìŠ¤ì˜ ì´ë¦„ì´ë‹¤."
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr "Sorted ì½œë ‰ì…˜ë“¤ì€ <literal>java.util.TreeSet</literal> ë˜ëŠ” <literal>java.util.TreeMap</literal>처럼 í–‰ë™í•œë‹¤."
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë°ì´í„°ë² ì´ìŠ¤ ê·¸ ìžì²´ê°€ ì½œë ‰ì…˜ ìš”ì†Œë“¤ì„ ìˆœì„œì§€ìš°ë„ë¡(order)ì›í• 경우 <literal>set</literal>, <literal>bag</literal> ë˜ëŠ”<literal>map</literal> ë§¤í•‘ë“¤ì— ëŒ€í•´ <literal>order-by</literal> ì†ì„±ì„ 사용하ë¼. ì´ í•´ê²°ì±…ì€ JDK 1.4 ì´ìƒì˜ ë²„ì „ì—서만 ì´ìš© 가능하다(ê·¸ê²ƒì€ <literal>LinkedHashSet</literal> ë˜ëŠ” <literal>LinkedHashMap</literal>ì„ ì‚¬ìš©í•˜ì—¬ 구현ëœë‹¤). ì´ê²ƒì€ 메모리 ë‚´ê°€ ì•„ë‹Œ, SQL ì§ˆì˜ ë‚´ì—ì„œ 순서지움(ordering)ì„ ìˆ˜í–‰í•œë‹¤."
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr "<literal>order-by</literal> ì†ì„±ì˜ ê°’ì€ HQL 순서지움(ordering)ì´ ì•„ë‹ˆë¼ SQL 순서지움(ordering)ìž„ì„ ë…¸íŠ¸í•˜ë¼!"
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr "ì—°ê´€ë“¤ì€ ì½œë ‰ì…˜ <literal>filter()</literal>를 사용하여 실행 ì‹œì— ì–´ë–¤ ìž„ì˜ì˜ criteria(기준)ì„ ì‚¬ìš©í•˜ì—¬ ì •ë ¬(sort)ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr "양방향 연관들"
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr "<emphasis>ì–‘ë°©í–¥ ì—°ê´€</emphasis>ì€ ì—°ê´€ì˜ ì–‘ \"ë(end)들\"로부터 네비게ì´ì…˜ì„ 허용한다. ë‘ ê°€ì§€ ì¢…ë¥˜ì˜ ì–‘ë°©í–¥ ì—°ê´€ë“¤ì´ ì§€ì›ëœë‹¤:"
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr "one-to-many"
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr "한쪽 ëì— set ë˜ëŠ” bag ê°’ì„ ê°–ê³ , 다른 쪽 ê¸‘ì— ë‹¨ì¼ ê°’ì„ ê°€ì§„ ì—°ê´€"
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr "many-to-many"
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr "ì–‘ ëì—ì„œ set ë˜ëŠ” bag ê°’ì„ ê°€ì§„ ì—°ê´€"
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr "ë‹¹ì‹ ì€ ë™ì¼í•œ ë‘ ê°œì˜ many-to-many ì—°ê´€ë“¤ì„ ë™ì¼í•œ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ë¡œ 간단하게 ë§¤í•‘í•˜ê³ í•œ 쪽 ëì„ <emphasis>inverse</emphasis>(ë‹¹ì‹ ì˜ ì„ íƒì€ 하나ì´ì§€ë§Œ, ê·¸ê²ƒì€ ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ì¼ ìˆ˜ 없다)ë¡œ ì„ ì–¸í•¨ìœ¼ë¡œì¨ í•˜ë‚˜ì˜ ì–‘ë°©í–¥ many-to-many ì—°ê´€ì„ ì§€ì •í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr "다ìŒì€ ì–‘ë°©í–¥ many-to-many ì—°ê´€ì— ê´€í•œ ì˜ˆì œì´ë‹¤; ê°ê°ì˜ ì¹´í…Œê³ ë¦¬ëŠ” ë§Žì€ ì•„ì´í…œë“¤ì„ 가질 수 ìžˆê³ ê°ê°ì˜ ì•„ì´í…œì€ ë§Žì€ ì¹´í…Œê³ ë¦¬ë“¤ ì†ì— ìžˆì„ ìˆ˜ 있다:"
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>
+\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr "ì—°ê´€ì˜ inverse ë(end)ì— ëŒ€í•´ì„œë§Œ 행해진 ë³€ê²½ë“¤ì€ ì˜ì†í™” ë˜ì§€ <emphasis>않는다</emphasis>. ì´ê²ƒì€ Hibernateê°€ ëª¨ë“ ì–‘ë°©í–¥ ì—°ê´€ì— ëŒ€í•´ 메모리 ë‚´ì— ë‘ ê°œì˜ í‘œìƒë“¤ì„ 갖는다는 ì ì„ ì˜ë¯¸í•œë‹¤: A로부터 Bë¡œì˜ í•˜ë‚˜ì˜ ë§í¬ì™€ B로부터 Aë¡œì˜ ë˜ ë‹¤ë¥¸ ë§í¬. ë§Œì¼ ë‹¹ì‹ ì´ ìžë°” ê°ì²´ ëª¨í˜•ì— ëŒ€í•´ ê·¸ë¦¬ê³ ìžë°”ì—ì„œ many-to-many 관계를 ìƒì„±ì‹œí‚¤ëŠ” ë°©ë²•ì— ëŒ€í•´ ìƒê°í•˜ë©´ ì´ê²ƒì€ ì´í•´í•˜ê¸°ê°€ ë” ì‰½ë‹¤:"
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr "non-inverse ì¸¡ì€ ë©”ëª¨ë¦¬ ë‚´ í‘œìƒì„ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ì €ìž¥í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr "ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ one-to-many ì—°ê´€ì„ í•˜ë‚˜ì˜ many-to-one 연관으로서 ë™ì¼í•œ í…Œì´ë¸” 컬럼(들)ë¡œ ë§¤í•‘í•˜ê³ many-ê°’ì„ ê°€ì§„ ë(end)ì„ <literal>inverse=\"true\"</literal>ë¡œ ì„ ì–¸í•¨ìœ¼ë¡œì¨ í•˜ë‚˜ì˜ ì–‘ë°©í–¥ ì—°ê´€ì„ ì •ì˜í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr "ì—°ê´€ì˜ í•œìª½ ëì„ <literal>inverse=\"true\"</literal>ë¡œ 매핑하는 ê²ƒì€ cascadeë“¤ì„ ê°€ì§„ 오í¼ë ˆì´ì…˜ì— ì˜í–¥ì„ 주지 않으며, ì´ê²ƒë“¤ì€ orthogonal(ì§êµ) ê°œë…들ì´ë‹¤!"
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr "ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ë“¤ì„ ê°€ì§„ ì–‘ë°©í–¥ 연관들"
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr "한쪽 ëì´ í•˜ë‚˜ì˜ <literal><list></literal> ë˜ëŠ” <literal><map></literal>으로서 표현ë˜ëŠ” ì–‘ë°©í–¥ ì—°ê´€ì€ íŠ¹ë³„í•œ ê²€í† ë¥¼ 필요로 한다. ë§Œì¼ ì¸ë±ìŠ¤ 컬럼으로 매핑ë˜ëŠ” child í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ê°€ 하나 존재한다면 ë¬¸ì œê°€ ì—†ê³ , 우리는 ì½œë ‰ì…˜ 매핑 ìƒì— <literal>inverse=\"true\"</literal>를 사용하여 계ì†í• 수 있다:"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr "그러나 ë§Œì¼ child í´ëž˜ìŠ¤ ìƒì— 그런 프로í¼í‹°ê°€ 존재하지 ì•Šì„ ê²½ìš°, 우리는 ê·¸ ì—°ê´€ì„ ì§„ì •í•˜ê²Œ 양방향으로 ê°„ì£¼í• ìˆ˜ 없다 (다른 쪽 ëì—ì„œ ì´ìš©ê°€ëŠ¥í•˜ì§€ ì•Šì€ ê·¸ ì—°ê´€ì˜ ëì—ì„œ ì´ìš© 가능한 ì •ë³´ê°€ 존재한다). ì´ ê²½ìš°ì— ìš°ë¦¬ëŠ” ê·¸ ì½œë ‰ì…˜ì„ <literal>inverse=\"true\"</literal>ë¡œ 매핑시킬 수 없다. ëŒ€ì‹ ì— ìš°ë¦¬ëŠ” ë‹¤ìŒ ë§¤í•‘ì„ ì‚¬ìš©í• ìˆ˜ 있다:"
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr "ì´ ë§¤í•‘ì—ì„œ ê·¸ ì—°ê´€ì˜ ì½œë ‰ì…˜ ê°’ì„ ê°€ì§„ ëì´ foreign í‚¤ì— ëŒ€í•œ ì—…ë°ì´íŠ¸ ì±…ìž„ì´ ìžˆìŒì„ 노트하ë¼."
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr "Ternary associations(세겹 연관들)"
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr "세 ê²¹ì˜ ì—°ê´€ì„ ë§¤í•‘í•˜ëŠ” 세 가지 가능한 ì ‘ê·¼ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤. í•˜ë‚˜ì˜ ì ‘ê·¼ë²•ì€ ê·¸ê²ƒì˜ ì¸ë±ìŠ¤ë¡œì„œ 연관관계를 가진 <literal>Map</literal>ì„ ì‚¬ìš©í•˜ëŠ” 것ì´ë‹¤:"
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr "ë‘ ë²ˆì§¸ ì ‘ê·¼ë²•ì€ ê·¸ ì—°ê´€ì„ ì—”í‹°í‹° í´ëž˜ìŠ¤ë¡œì„œ 단순하게 리모ë¸ë§ 하는 것ì´ë‹¤. ì´ê²ƒì€ 우리가 가장 공통ì 으로 사용하는 ì ‘ê·¼ë²•ì´ë‹¤."
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr "마지막 ëŒ€ì•ˆì€ ìš°ë¦¬ê°€ ë‚˜ì¤‘ì— ë…¼ì˜í•˜ê²Œ ë composite ìš”ì†Œë“¤ì„ ì‚¬ìš©í•˜ëŠ” 것ì´ë‹¤."
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr "<literal><idbag></literal> 사용하기"
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ composite í‚¤ë“¤ì´ ë‚˜ìœ ê²ƒì´ê³ ì—”í‹°í‹°ë“¤ì´ í•©ì„± ì‹ë³„ìžë“¤(대용 키들, surrogate keys)ì„ ê°€ì ¸ì•¼ 한다는 ìš°ë¦¬ì˜ ê²¬í•´ë¥¼ ì „ì 으로 ìˆ˜ìš©í• ê²½ìš°, ë‹¹ì‹ ì€ ìš°ë¦¬ê°€ 지금까지 ë³´ì—¬ì£¼ì—ˆë˜ ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ê³¼ many to many ì—°ê´€ë“¤ì´ ëª¨ë‘ composite í‚¤ë“¤ì„ ê°€ì§„ í…Œì´ë¸”들로 매핑ëœë‹¤ëŠ” 약간 ì´ìƒí•œ ì ì„ ë°œê²¬í• ìˆ˜ë„ ìžˆë‹¤! ì´ì œ ì´ ì ì€ ê½¤ ë…¼ì˜ì˜ 여지가 있다; 순수한 ì—°ê´€ í…Œì´ë¸”ì€ (ë¹„ë¡ composite ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜<emphasis>ì¼ ìˆ˜ë„</emphasis> 있ì„지ë¼ë„) 대용 키로부터 ë§Žì€ ì´ì ì„ ì·¨í•˜ì§€ 않는 것처럼 ë³´ì¸ë‹¤. 그럼ì—ë„ ë¶ˆêµ¬í•˜ê³ Hibernate는 ë‹¹ì‹ ì´ ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ê³¼ many to many ì—°ê´€ë“¤ì„ ëŒ€ìš© 키를 가진 í…Œì´ë¸”ë¡œ 매핑시키는 ê²ƒì„ ë‹¹ì‹ ì—게 허용해주는 íŠ¹ì§•ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr "<literal><idbag></literal> 요소는 bag ì˜ë¯¸ë¥¼ 가진 <literal>List</literal>(ë˜ëŠ” <literal>Collection</literal>)ì„ ë§¤í•‘í•˜ë„ë¡ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr "ë‹¹ì‹ ì´ ë³¼ 수 있듯ì´, <literal><idbag></literal>ì€ ë§ˆì¹˜ 엔티티 í´ëž˜ìŠ¤ì¸ì–‘ synthetic id generator(합성 id ìƒì„±ê¸°)를 갖는다! 다른 대용 키는 ê°ê°ì˜ ì½œë ‰ì…˜ í–‰ì— í• ë‹¹ëœë‹¤. 하지만 Hibernate는 íŠ¹ì • í–‰ì˜ ëŒ€ìš© 키 ê°’ì„ ë°œê²¬í•˜ëŠ” ë©”ì»¤ë‹ˆì¦˜ì„ ì œê³µí•˜ì§€ 않는다."
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr "<literal><idbag></literal>ì˜ ì—…ë°ì´íŠ¸ í¼í¬ë¨¼ìŠ¤ëŠ” ì •ê·œ <literal><bag></literal> 보다 훨씬 좋다는 ì ì„ ë…¸íŠ¸í•˜ë¼! Hibernate는 마치 list, map, ë˜ëŠ” setì¸ì–‘, 개별 í–‰ë“¤ì„ íš¨ìœ¨ì 으로 위치지울 수 ìžˆê³ ê·¸ê²ƒë“¤ì„ ê°œë³„ì 으로 ì—…ë°ì´íŠ¸ 하거나 ì‚ì œì‹œí‚¬ 수 있다."
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr "현재 구현ì—ì„œ, <literal>native</literal> ì‹ë³„ìž ìƒì„± ë°©ë„는 <literal><idbag></literal> ì½œë ‰ì…˜ ì‹ë³„ìžë“¤ì— 대해 지ì›ë˜ì§€ 않는다."
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr "ì½œë ‰ì…˜ ì˜ˆì œë“¤"
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr "ì•žì˜ ì ˆë“¤ì€ ê½¤ 혼ë™ìŠ¤ëŸ½ë‹¤. ë”°ë¼ì„œ ì˜ˆì œë¥¼ 살펴보ìž. ë‹¤ìŒ í´ëž˜ìŠ¤:"
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr "는 <literal>Child</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 가진 í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì„ ê°–ê³ ìžˆë‹¤. ë§Œì¼ ê°ê°ì˜ ìžì‹ì´ 최소한 í•œ ê°œì˜ ë¶€ëª¨ë¥¼ 가질 경우, ëŒ€ë¶€ë¶„ì˜ ê³ ìœ í•œ ë§¤í•‘ì€ one-to-many ì—°ê´€ì´ë‹¤:"
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr "ì´ê²ƒì€ ë‹¤ìŒ í…Œì´ë¸” ì •ì˜ë“¤ë¡œ 매핑ëœë‹¤:"
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr "ë§Œì¼ ë¶€ëª¨ê°€ <emphasis>필수ì </emphasis>ì´ë¼ë©´, ì–‘ë°©í–¥ one-to-many 연관관계를 사용하ë¼:"
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr "<literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ 주목하ë¼:"
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr "대안ì 으로, ë§Œì¼ ë‹¹ì‹ ì´ ì´ ì—°ê´€ê´€ê³„ê°€ 단방향ì´ì–´ì•¼ í•¨ì„ ì ˆëŒ€ì 으로 ì—ì„¤í• ê²½ìš°, ë‹¹ì‹ ì€ <literal><key></literal> 매핑 ìƒì— <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ì„ ì–¸í• ìˆ˜ 있다:"
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr "반면ì—, ë§Œì¼ ìžì‹ì´ 여러 ë¶€ëª¨ë“¤ì„ ê°€ì§ˆ 수 ìžˆì„ ê²½ìš°, many-to-many ì—°ê´€ì´ ì ì ˆí•˜ë‹¤:"
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr "í…Œì´ë¸” ì •ì˜ë“¤:"
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr "부모/ìžì‹ 관계 ë§¤í•‘ì„ ì—°ìŠµí•˜ëŠ” ë” ë§Žì€ ì˜ˆì œë“¤ê³¼ ì „ì²´ ë¦¬í—ˆì„¤ì€ <xref linkend=\"example-parentchild\"/>를 ë³´ë¼."
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr "ë¹„ë¡ ë” ë§Žì€ ì‹ ì¢… ì—°ê´€ ë§¤í•‘ë“¤ì´ ê°€ëŠ¥í• ì§€ë¼ë„, 우리는 ë‹¤ìŒ ìž¥ì—ì„œ ëª¨ë“ ê°€ëŠ¥ì„±ë“¤ì„ ë¶„ë¥˜í• ê²ƒì´ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,532 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr "Component 매핑"
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr "<emphasis>component</emphasis>ì˜ ê°œë…ì€ Hibernateì—ì„œ 다른 ìš©ë„ë¡œ 몇몇 다른 컨í…스트들 ë‚´ì—ì„œ 재사용ëœë‹¤."
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr "ì¢…ì† ê°ì²´ë“¤"
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr "í•˜ë‚˜ì˜ ì»´í¬ë„ŒíŠ¸ëŠ” 엔티티 참조가 ì•„ë‹Œ, value 타입으로서 ì˜ì†í™” ë˜ëŠ” í•˜ë‚˜ì˜ í¬í•¨ëœ ê°ì²´ì´ë‹¤. \"ì»´í¬ë„ŒíŠ¸\" 용어는 (아키í…처 ìˆ˜ì¤€ì˜ ì»´í¬ë„ŒíŠ¸ë“¤ì´ ì•„ë‹Œ) composition(구성,합성)ì— ëŒ€í•œ ê°ì²´-지향ì ì¸ ê°œë…ì„ ì–¸ê¸‰í•œë‹¤. 예를 들어 ë‹¹ì‹ ì€ ë‹¤ìŒê³¼ ê°™ì´ ê°œì¸ì„ 모형화 시킬 ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr "ì´ì œ <literal>Name</literal>ì€ <literal>Person</literal>ì˜ ì»´í¬ë„ŒíŠ¸ë¡œì„œ ì˜ì†í™” ë ìˆ˜ë„ ìžˆë‹¤. <literal>Name</literal>ì´ ê·¸ê²ƒì˜ ì˜ì† 프로í¼í‹°ë“¤ì— 대한 getter 메소드와 setter 메소드를 ì •ì˜í•˜ì§€ë§Œ, ì–´ë–¤ ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì´ë‚˜ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ ì„ ì–¸í•˜ëŠ” ê²ƒì„ í•„ìš”ë¡œ 하지 ì•ŠìŒì„ 주목하ë¼."
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr "ìš°ë¦¬ì˜ Hibernate ë§¤í•‘ì€ ë‹¤ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:38
+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> ì»¬ëŸ¼ë“¤ì„ ê°€ì§ˆ 것ì´ë‹¤."
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr "ëª¨ë“ ê°’(value) 타입들처럼, ì»´í¬ë„ŒíŠ¸ë“¤ì€ ê³µìœ ëœ ì°¸ì¡°ë“¤ì„ ì§€ì›í•˜ì§€ 않는다. 달리 ë§í•´, ë‘ ëª…ì˜ ê°œì¸ë“¤ì€ ë™ì¼í•œ ì´ë¦„ì„ ê°€ì§ˆ 수 있지만, ë‘ ê°œì˜ person ê°ì²´ë“¤ì€ ì˜¤ì§ ê°’ ë§Œì´ \"ë™ì¼í•œ\" ë‘ ê°œì˜ ë…립ì ì¸ name ê°ì²´ë“¤ì„ í¬í•¨í• 것ì´ë‹¤. ì»´í¬ë„ŒíŠ¸ì˜ null ê°’ ì˜ë¯¸ëŠ” <emphasis>특별한 ìš©ë„를 위한 것ì´ë‹¤</emphasis>. í¬í•¨ëœ ê°ì²´ë¥¼ 다시 로드시킬 ë•Œ, Hibernate는 ëª¨ë“ ì»´í¬ë„ŒíŠ¸ ì»¬ëŸ¼ë“¤ì´ nullì¼ ê²½ìš°ì— ì „ì²´ ì»´í¬ë„ŒíŠ¸ê°€ nullì´ë¼ê³ ê°€ì •í• ê²ƒì´ë‹¤. ì´ê²ƒì€ ëŒ€ë¶€ë¶„ì˜ ìš©ë„ì— ë§žì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr "ì»´í¬ë„ŒíŠ¸ì˜ 프로í¼í‹°ë“¤ì€ ìž„ì˜ì˜ Hibernate íƒ€ìž…ì¼ ìˆ˜ 있다(ì½œë ‰ì…˜ë“¤, many-to-one 연관들, 다른 ì»´í¬ë„ŒíŠ¸ë“¤, 기타). ë‚´í¬ëœ ì»´í¬ë„ŒíŠ¸ë“¤ì€ ì‹ ì¢…ì˜ ì‚¬ìš©ë¡€ë¡œ 간주ë˜ì§€ <emphasis>ì•Šì„</emphasis> 것ì´ë‹¤. Hibernate는 매우 잘 ì •ì œëœ ê°ì²´ ëª¨í˜•ì„ ì§€ì›í•˜ë„ë¡ ê³ ì•ˆë˜ì–´ìžˆë‹¤."
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal><component></literal> 요소는 ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ë¥¼ í¬í•¨ë˜ëŠ” ì—”í‹°í‹°ì— ëŒ€í•œ ì— ì°¸ì¡°ë¡œì„œ 매핑시키는 <literal><parent></literal> 서브요소를 허용한다."
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr "ì¢…ì† ê°ì²´ë“¤ì„ 가진 ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤ì„ 가진 ì½œë ‰ì…˜ë“¤ì´ ì§€ì›ëœë‹¤(예를 들면 <literal>Name</literal> íƒ€ìž…ì„ ê°€ì§„ ë°°ì—´). <literal><element></literal> 태그를 <literal><composite-element></literal> 태그로 대체시켜서 ë‹¹ì‹ ì˜ ì»´í¬ë„ŒíŠ¸ ì½œë ‰ì…˜ì„ ì„ ì–¸í•˜ë¼."
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr "노트: ë§Œì¼ ë‹¹ì‹ ì´ composite 요소를 가진 í•˜ë‚˜ì˜ <literal>Set</literal>를 ì •ì˜í• 경우, <literal>equals()</literal>와 <literal>hashCode()</literal>를 ì •í™•í•˜ê²Œ 구현하는 ê²ƒì´ ë§¤ìš° 중요하다."
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr "Composite ìš”ì†Œë“¤ì€ ì»´í¬ë„ŒíŠ¸ë“¤ì„ í¬í•¨í•˜ì§€ë§Œ ì½œë ‰ì…˜ë“¤ì„ í¬í•¨í•˜ì§€ 않는다. ë§Œì¼ ë‹¹ì‹ ì˜ composite 요소 ìžì²´ê°€ ì»´í¬ë„ŒíŠ¸ë“¤ì„ í¬í•¨í• 경우, <literal><nested-composite-element></literal> 태그를 사용하ë¼. ì´ê²ƒì€ 꽤 ì‹ ì¢…ì˜ ê²½ìš°-그것들 ìžì²´ê°€ ì»´í¬ë„ŒíŠ¸ë“¤ì„ ê°–ê³ ìžˆëŠ” ì»´í¬ë„ŒíŠ¸ë“¤ì˜ ì½œë ‰ì…˜-ì´ë‹¤. ì´ ë‹¨ê³„ì—ì„œ ë‹¹ì‹ ì€ one-to-many ì—°ê´€ì´ ë” ì ì ˆí•œì§€ë¥¼ ë‹¹ì‹ ìŠ¤ìŠ¤ë¡œì—게 질문하게 ë 것ì´ë‹¤. í•˜ë‚˜ì˜ ì—”í‹°í‹°ë¡œì„œ composite 요소를 다시 모ë¸ë§í•˜ë ¤ê³ ì‹œë„í•˜ë¼ - 그러나 ìžë°” ëª¨í˜•ë“¤ì´ ë™ì¼í• 지ë¼ë„, 관계형 모형과 ì˜ì†í™” ì˜ë¯¸ë“¤ì€ ì—¬ì „ížˆ 약간 다르다."
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr "ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ <literal><set></literal>ì„ ì‚¬ìš© 중ì´ë¼ë©´, í•˜ë‚˜ì˜ composite 요소 ë§¤í•‘ì€ null 가능한 프로í¼í‹°ë“¤ì„ 지ì›í•˜ì§€ ì•ŠìŒì„ 노트하길 바란다. Hibernate는 ê°ì²´ë“¤ì„ ì‚ì œí• ë•Œ í•˜ë‚˜ì˜ ë ˆì½”ë“œë¥¼ ì‹ë³„í•˜ëŠ”ë° ê°ê°ì˜ 컬럼들 ê°’ì„ ì‚¬ìš©í•´ì•¼ 하며 (composite 요소 í…Œì´ë¸” ë‚´ì— ë³„ë„ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키 ì»¬ëŸ¼ì´ ì¡´ìž¬í•˜ì§€ 않는다), ê·¸ê²ƒì€ null ê°’ë“¤ì— ëŒ€í•´ì„œëŠ” 불가능하다. ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ composite-요소 ë‚´ì— not-null 프로í¼í‹°ë“¤ ë§Œì„ ì‚¬ìš©í•´ì•¼ 하거나 í•˜ë‚˜ì˜ <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> ë˜ëŠ” <literal><idbag></literal>ì„ ì„ íƒí•´ì•¼ 한다."
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 "composite ìš”ì†Œì— ëŒ€í•œ í•˜ë‚˜ì˜ íŠ¹ë³„í•œ 경우는 ë‚´í¬ëœ <literal><many-to-one></literal> 요소를 가진 composite 요소ì´ë‹¤. ì´ê°™ì€ ë§¤í•‘ì€ many-to-many ì—°ê´€ í…Œì´ë¸”ì˜ íŠ¹ë³„í•œ ì»¬ëŸ¼ë“¤ì„ composite 요소 í´ëž˜ìŠ¤ë¡œ 매핑시키는 ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다. 다ìŒì€ <literal>Order</literal>로부터 <literal>Item</literal>ìœ¼ë¡œì˜ many-to-many ì—°ê´€ì´ë‹¤. 여기서 <literal>purchaseDate</literal>, <literal>price</literal>, ê·¸ë¦¬ê³ <literal>quantity</literal>는 ì—°ê´€ì˜ í”„ë¡œí¼í‹°ë“¤ì´ë‹¤:"
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr "ë¬¼ë¡ , ì–‘ë°©í–¥ ì—°ê´€ 네비게ì´ì…˜ì˜ 경우, 다른 측 ìƒì— 있는 purchaseì— ëŒ€í•œ 참조가 ì¡´ìž¬í• ìˆ˜ 없다. ì»´í¬ë„ŒíŠ¸ë“¤ì´ ê°’(value) 타입들ì´ê³ ê³µìœ ëœ ì°¸ì¡°ë“¤ì„ í—ˆìš©í•˜ì§€ ì•ŠìŒì„ 기억하ë¼. í•˜ë‚˜ì˜ <literal>Purchase</literal>는<literal>Order</literal>를 가진 set ë‚´ì— ìžˆì„ ìˆ˜ 있지만, ê·¸ê²ƒì€ ë™ì‹œì— <literal>Item</literal>ì— ì˜í•´ 참조ë 수 없다."
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr "심지어 세겹ì˜(ë˜ëŠ” 네 ê²¹ì˜, 기타) ì—°ê´€ë“¤ì´ ê°€ëŠ¥í•˜ë‹¤:"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr "composite ìš”ì†Œë“¤ì€ ë‹¤ë¥¸ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ 연관들과 ë™ì¼í•œ êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ì—¬ 질ì˜ë“¤ ë‚´ì— ë‚˜íƒ€ë‚ ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr "Map ì¸ë±ìŠ¤ë“¤ë¡œì„œ ì»´í¬ë„ŒíŠ¸ë“¤"
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr "<literal><composite-map-key></literal> 요소는 ë‹¹ì‹ ì—게 í•˜ë‚˜ì˜ ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤ë¥¼ í•˜ë‚˜ì˜ <literal>Map</literal>ì˜ í‚¤ë¡œì„œ 매핑시키ë„ë¡ í•œë‹¤. ë‹¹ì‹ ì€ ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤ ìƒì—ì„œ <literal>hashCode()</literal>와 <literal>equals()</literal>를 ì •í™•í•˜ê²Œ 오버ë¼ì´ë“œ 시키ë„ë¡ í•˜ë¼."
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr "composite ì‹ë³„ìžë“¤ë¡œì„œ ì»´í¬ë„ŒíŠ¸ë“¤"
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr "ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ì»´í¬ë„ŒíŠ¸ë¥¼ í•˜ë‚˜ì˜ ì—”í‹°í‹° í´ëž˜ìŠ¤ì— 대한 í•˜ë‚˜ì˜ ì‹ë³„ìžë¡œì„œ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì˜ ì»´í¬ë„ŒíŠ¸ í´ëž˜ìŠ¤ëŠ” ì–´ë–¤ ì‚¬ì–‘ë“¤ì„ ì¶©ì¡±ì‹œì¼œì•¼ 한다:"
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr "ê·¸ê²ƒì€ <literal>java.io.Serializable</literal>ì„ êµ¬í˜„í•´ì•¼ 한다."
+
+#: index.docbook:170
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr "ê·¸ê²ƒì€ composite 키 등가(equality)ì— ëŒ€í•œ ë°ì´í„°ë² ì´ìŠ¤ ê°œë…ê³¼ ì¼ì¹˜ë˜ê²Œ, <literal>equals()</literal>와 <literal>hashCode()</literal>를 다시 구현해야 한다."
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr "노트: Hibernate3ì—ì„œ, ë‘ ë²ˆì§¸ ì‚¬ì–‘ì€ Hibernateì˜ ì ˆëŒ€ì 으로 엄격한 ì‚¬ì–‘ì´ ì•„ë‹ˆë‹¤. 그러나 아무튼 ê·¸ê²ƒì„ í–‰í•˜ë¼."
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr "ë‹¹ì‹ ì€ compsite í‚¤ë“¤ì„ ìƒì„±ì‹œí‚¤ëŠ”ë° <literal>IdentifierGenerator</literal>를 ì‚¬ìš©í• ìˆ˜ 없다. ëŒ€ì‹ ì— ì–´í”Œë¦¬ì¼€ì´ì…˜ì€ 그것 ìžì‹ ì˜ ì‹ë³„ìžë“¤ì„ í• ë‹¹í•´ì•¼ 한다."
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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><id></literal> ì„ ì–¸ ìœ„ì¹˜ì— (ë‚´í¬ëœ <literal><key-property></literal> ìš”ì†Œë“¤ì„ ê°€ì§„) <literal><composite-id></literal> 태그를 사용하ë¼. 예를 들어, <literal>OrderLine</literal> í´ëž˜ìŠ¤ëŠ” <literal>Order</literal>ì˜ (composite) 프ë¼ì´ë¨¸ë¦¬ í‚¤ì— ì˜ì¡´í•˜ëŠ” 프ë¼ì´ë¨¸ë¦¬ 키를 갖는다."
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr "ì´ì œ <literal>OrderLine</literal> í…Œì´ë¸”ì„ ì°¸ì¡°í•˜ëŠ” ìž„ì˜ì˜ foreign í‚¤ë“¤ì´ ë˜í•œ compsiteì´ë‹¤. ë‹¹ì‹ ì€ ë‹¤ë¥¸ í´ëž˜ìŠ¤ë“¤ì— 대한 ë‹¹ì‹ ì˜ ë§¤í•‘ë“¤ ì†ì— ì´ê²ƒì„ ì„ ì–¸í•´ì•¼ 한다. <literal>OrderLine</literal>ì— ëŒ€í•œ í•˜ë‚˜ì˜ ì—°ê´€ì€ ë‹¤ìŒê³¼ ê°™ì´ ë§¤í•‘ë 것ì´ë‹¤:"
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr "(<literal><column></literal> 태그가 ëª¨ë“ ê³³ì—ì„œ <literal>column</literal> ì†ì„±ì— 대한 ëŒ€ì•ˆìž„ì„ ë…¸íŠ¸í•˜ë¼.)"
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr "<literal>OrderLine</literal>ì— ëŒ€í•œ <literal>many-to-many</literal> ì—°ê´€ì€ ë˜í•œ composite foreign 키를 사용한다:"
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr "<literal>Order</literal>ì—ì„œ <literal>OrderLine</literal>ë“¤ì˜ ì½œë ‰ì…˜ì´ ì‚¬ìš©ë 것ì´ë‹¤:"
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr "(통ìƒì 으로 <literal><one-to-many></literal> 요소는 ì»¬ëŸ¼ë“¤ì„ ì„ ì–¸í•˜ì§€ 않는다.)"
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr "ë§Œì¼ <literal>OrderLine</literal> ìžì²´ê°€ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì„ ì†Œìœ í• ê²½ìš°, ê·¸ê²ƒì€ ë˜í•œ í•˜ë‚˜ì˜ composite foreign 키를 갖는다."
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr "ë™ì ì¸ ì»´í¬ë„ŒíŠ¸ë“¤"
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr "ë‹¹ì‹ ì€ <literal>Map</literal> íƒ€ìž…ì˜ í”„ë¡œí¼í‹°ë¥¼ 매핑시킬 ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr "<literal><dynamic-component></literal> ë§¤í•‘ì˜ ì˜ë¯¸ëŠ” <literal><component></literal>와 ë™ì¼í•˜ë‹¤. ì´ëŸ° ì¢…ë¥˜ì˜ ë§¤í•‘ì˜ ìž¥ì ì€ ë°°ì¹˜ ì‹œì— ë‹¨ì§€ 매핑 문서를 íŽ¸ì§‘í•¨ìœ¼ë¡œì¨ ê·¸ beanì˜ ì‹¤ì œ 프로í¼í‹°ë“¤ì„ ê²°ì •í•˜ëŠ” 가용성ì´ë‹¤. 매핑 ë¬¸ì„œì— ëŒ€í•œ 런타임 처리는 ë˜í•œ DOM 파서를 사용하여 가능하다. ë” ì¢‹ê²ŒëŠ” ë‹¹ì‹ ì´ <literal>Configuration</literal> ê°ì²´ë¥¼ 통해 Hibernateì˜ êµ¬ì„±-ì‹œ ë©”íƒ€ëª¨í˜•ì— ì ‘ê·¼í• ìˆ˜ 있다(ê·¸ë¦¬ê³ ë³€ê²½ì‹œí‚¬ 수 있다)"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1598 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr "<title>구성</title>"
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr "Hibernateê°€ ë§Žì€ ë‹¤ë¥¸ 환경들ì—ì„œ ë™ìž‘하ë„ë¡ ì„¤ê³„ë˜ì–´ 있으므로, ë§Žì€ ê°œìˆ˜ì˜ êµ¬ì„± 파ë¼ë¯¸í„°ë“¤ì´ 존재한다. 다행히 ëŒ€ë¶€ë¶„ì€ ìœ ì˜ë¯¸í•œ ë””í´íŠ¸ 값들ì´ê³ Hibernate는 다양한 ì˜µì…˜ë“¤ì„ ë³´ì—¬ì£¼ëŠ” <literal>etc/</literal> ë‚´ì˜ ì˜ˆì œ íŒŒì¼ <literal>hibernate.properties</literal>ë¡œ ë°°í¬ëœë‹¤. ë‹¹ì‹ ì€ ë‹¨ì§€ ë‹¹ì‹ ì˜ classpath 경로 ì†ì— ê·¸ 파ì¼ì„ ì§‘ì–´ë„£ê³ ê·¸ê²ƒì„ ì»¤ìŠ¤íŠ¸ë§ˆì´ì§•í•˜ê¸°ë§Œ 해야 한다."
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr "프로그램 ìƒì˜ 구성"
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr "<literal>org.hibernate.cfg.Configuration</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” 어플리케ì´ì…˜ì˜ Java íƒ€ìž…ë“¤ì„ SQL ë°ì´í„°ë² ì´ìŠ¤ íƒ€ìž…ìœ¼ë¡œì˜ ì „ì²´ 매핑 ì§‘í•©ì„ í‘œí˜„í•œë‹¤. <literal>Configuration</literal>ì€ (불변ì˜) <literal>SessionFactory</literal>를 ë¹Œë“œí•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤. ë§¤í•‘ë“¤ì€ ì—¬ëŸ¬ XML 매핑 파ì¼ë“¤ë¡œë¶€í„° ì»´íŒŒì¼ ëœë‹¤."
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr "ë‹¹ì‹ ì€ <literal>Configuration</literal> ì¸ìŠ¤í„´ìŠ¤ë¥¼ 초기화 ì‹œí‚¤ê³ XML 매핑 ë¬¸ì„œë“¤ì„ ì§€ì •í•¨ìœ¼ë¡œì¨ <literal>Configuration</literal> ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì–»ì„ ìˆ˜ 있다. ë§Œì¼ ë§¤í•‘ 파ì¼ë“¤ì´ classpath ë‚´ì— ìžˆë‹¤ë©´, <literal>addResource()</literal>를 사용하ë¼:"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr "(때때로 ë” ë‚˜ì€) 다른 ë°©ë²•ì€ ë§¤í•‘ëœ í´ëž˜ìŠ¤ë¥¼ ì§€ì •í•˜ëŠ” 것ì´ê³ , Hibernateë¡œ 하여금 ë‹¹ì‹ ì„ ìœ„í•´ 매핑 문서를 ì°¾ë„ë¡ í•˜ë¼:"
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr "그때 Hibernate는 classpath ë‚´ì—ì„œ <literal>/org/hibernate/auction/Item.hbm.xml</literal>ê³¼ <literal>/org/hibernate/auction/Bid.hbm.xml</literal>ë¡œ ëª…ëª…ëœ ë§¤í•‘ 파ì¼ë“¤ì„ ë£©ì—…í• ê²ƒì´ë‹¤. ì´ ì ‘ê·¼ë²•ì€ ìž„ì˜ì˜ í•˜ë“œì½”ë”©ëœ íŒŒì¼ ì´ë¦„ë“¤ì„ ì œê±°í•œë‹¤."
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr "<literal>Configuration</literal>ì€ ë˜í•œ 구성 프로í¼í‹°ë“¤ì„ ì§€ì •í•˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤:"
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr "ì´ê²ƒì€ ì»¨í”¼ê·¸ë ˆì´ì…˜ 프로í¼í‹°ë“¤ì„ Hibernateì— ì „ë‹¬í•˜ëŠ” ìœ ì¼í•œ ë°©ë²•ì´ ì•„ë‹ˆë‹¤. 여러 가지 ì˜µì…˜ë“¤ì€ ë‹¤ìŒì„ í¬í•¨í•œë‹¤:"
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr "<literal>java.util.Properties</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ <literal>Configuration.setProperties()</literal>ì— ì „ë‹¬í•œë‹¤ ."
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr "classpathì˜ ë£¨íŠ¸ ë””ë ‰í† ë¦¬ì— <literal>hibernate.properties</literal>를 위치지운다."
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr "<literal>java -Dproperty=value</literal>를 사용하여 <literal>System</literal> 프로í¼í‹°ë“¤ì„ ì„¤ì •í•œë‹¤."
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr "<literal>hibernate.cfg.xml</literal>ì— <literal><property></literal> ìš”ì†Œë“¤ì„ í¬í•¨í•œë‹¤ (ë‚˜ì¤‘ì— ë…¼ì˜ë¨)."
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr "ë‹¹ì‹ ì´ ë¹ ë¥´ê²Œ ì‹œìž‘í•˜ê³ ì›í• 경우 <literal>hibernate.properties</literal>는 가장 쉬운 ì ‘ê·¼ë²•ì´ë‹¤."
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr "<literal>Configuration</literal>ì€ ì‹œìž‘ ì‹œ(startup-time) ê°ì²´ë¡œì„œ ì¼ë‹¨ <literal>SessionFactory</literal>ê°€ ìƒì„±ë˜ë©´ í기ë˜ê²Œë” ì˜ˆì •ë˜ì–´ 있다."
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr "SessionFactory 얻기"
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr "ëª¨ë“ ë§¤í•‘ë“¤ì´ <literal>Configuration</literal>ì— ì˜í•´ 파싱ë˜ì—ˆì„ ë•Œ, 어플리케ì´ì…˜ì€ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 íŒ©í† ë¦¬ë¥¼ 얻어야 한다. ì´ íŒ©í† ë¦¬ëŠ” ëª¨ë“ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì“°ë ˆë“œë“¤ì— ì˜í•´ ê³µìœ ë˜ë„ë¡ ê³ ì•ˆë˜ì—ˆë‹¤:"
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr "하지만 Hibernate는 ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ 하나 ì´ìƒì˜ <literal>SessionFactory</literal>를 초기화 시키는 ê²ƒì„ í—ˆìš©í•œë‹¤. ì´ê²ƒì€ ë‹¹ì‹ ì´ í•˜ë‚˜ ì´ìƒì˜ ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 사용하는 ê²½ìš°ì— ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr "JDBC 커넥션들"
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr "대개 ë‹¹ì‹ ì€ <literal>SessionFactory</literal>ë¡œ 하여금 ë‹¹ì‹ ì„ ìœ„í•œ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ìƒì„±ì‹œí‚¤ê³ í’€ë§ì‹œí‚¤ëŠ” ê²ƒì„ ì›í•œë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì´ ì ‘ê·¼ë²•ì„ ì·¨í• ê²½ìš°, í•œ ê°œì˜ <literal>Session</literal>ì„ ì—¬ëŠ” ê²ƒì€ ë‹¤ìŒê³¼ ê°™ì´ ê°„ë‹¨í•˜ë‹¤:"
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr "ë‹¹ì‹ ì´ ë°ì´í„°ë² ì´ìŠ¤ì— 대한 ì ‘ê·¼ì„ ìš”ì²í•˜ëŠ” ì–´ë–¤ ê²ƒì„ í–‰í•˜ìž ë§ˆìž, í•œ ê°œì˜ JDBC ì»¤ë„¥ì…˜ì´ ê·¸ 풀로부터 얻어질 것ì´ë‹¤."
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr "ì´ê²ƒì´ ë™ìž‘하ë„ë¡ í•˜ê¸° 위해서, 우리는 몇몇 JDBC 커넥션 프로í¼í‹°ë“¤ì„ Hibernateì— ì „ë‹¬í• í•„ìš”ê°€ 있다. ëª¨ë“ Hibernate 프로í¼í‹° ì´ë¦„들과 ì˜ë¯¸ë¡ ë“¤ì€ <literal>org.hibernate.cfg.Environment</literal> í´ëž˜ìŠ¤ ìƒì— ì •ì˜ë˜ì–´ 있다. 우리는 ì´ì œ JDBC 커넥션 êµ¬ì„±ì„ ìœ„í•œ 가장 중요한 ì„¤ì •ë“¤ì„ ì„¤ëª…í• ê²ƒì´ë‹¤."
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¤ìŒ í”„ë¡œí¼í‹°ë“¤ì„ ì„¤ì •í• ê²½ìš° Hibernate는 <literal>java.sql.DriverManager</literal>를 사용하여 ì»¤ë„¥ì…˜ë“¤ì„ ì–»ì„ ê²ƒì´ë‹¤(ê·¸ë¦¬ê³ í’€ë§ì‹œí‚¬ 것ì´ë‹¤):"
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr "Hibernate JDBC 프로í¼í‹°ë“¤"
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr "프로í¼í‹° ì´ë¦„"
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr "<entry>ìš©ë„</entry>"
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr "jdbc ë“œë¼ì´ë²„ í´ëž˜ìŠ¤"
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr "jdbc URL"
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:179
+msgid "database user"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ 사용ìž"
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:187
+msgid "database user password"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì‚¬ìš©ìž íŒ¨ìŠ¤ì›Œë“œ"
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr "hibernate.connection.pool_size"
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr "í’€ë§ëœ ì»¤ë„¥ì…˜ë“¤ì˜ ìµœëŒ€ 개수"
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr "하지만 Hibernate ìžì‹ ì˜ ì»¤ë„¥ì…˜ í’€ë§ ì•Œê³ ë¦¬ì¦˜ì€ ì•„ì£¼ 기본ì ì´ë‹¤. ê·¸ê²ƒì€ ë‹¹ì‹ ì´ ì‹œìž‘í•˜ëŠ” ê²ƒì„ ë„ì™€ì£¼ë ¤ê³ ì˜ë„ë˜ì—ˆê³ <emphasis>ì œí’ˆ 시스템 ìš©ë„ ë˜ëŠ” í¼í¬ë¨¼ìŠ¤ 테스트용으로는 ê³ ì•ˆë˜ì§€ 않았다</emphasis>. 최ìƒì˜ í¼í¬ë¨¼ìŠ¤ì™€ ì•ˆì •ì„±ì„ ìœ„í•´ì„œëŠ” ì œ 3ì˜ í’€ì„ ì‚¬ìš©í•˜ë¼. 즉 <literal>hibernate.connection.pool_size</literal> 프로í¼í‹°ë¥¼ 커넥션 í’€ ì§€ì • ì„¤ì •ë“¤ë¡œ 대체하ë¼. ì´ê²ƒì€ Hibernateì˜ ë‚´ë¶€ poolì„ ì˜¤í”„ì‹œí‚¬ 것ì´ë‹¤. 예를 들어 ë‹¹ì‹ ì€ C3P0를 ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr "C3P0는 <literal>lib</literal> ë””íŽ™í† ë¦¬ ì†ì— Hibernateì— ë°°í¬ëœ 오픈 소스 JDBC 커넥션 í’€ì´ë‹¤. ë‹¹ì‹ ì´ <literal>hibernate.c3p0.*</literal> 프로í¼í‹°ë“¤ì„ ì„¤ì •í• ê²½ìš° Hibernate는 커넥션 í’€ë§ì„ 위해 ê·¸ê²ƒì˜ <literal>C3P0ConnectionProvider</literal>를 ì‚¬ìš©í• ê²ƒì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ Proxoolì„ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우 패키지화 ëœ <literal>hibernate.properties</literal>를 ì°¸ì¡°í•˜ê³ ì¶”ê°€ ì •ë³´ëŠ” Hibernate 웹 사ì´íŠ¸ë¥¼ 참조하ë¼."
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr "다ìŒì€ C3P0ì— ëŒ€í•œ 사용하는 ì˜ˆì œ <literal>hibernate.properties</literal> 파ì¼ì´ë‹¤:"
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr "어플리케ì´ì…˜ 서버 ë‚´ë¶€ì˜ ìš©ë„ë¡œ, ë‹¹ì‹ ì€ JNDIë¡œ 등ë¡ëœ 어플리케ì´ì…˜ 서버 <literal>Datasource</literal>로부터 ì»¤ë„¥ì…˜ì„ ì–»ê¸° 위해 í•ìƒ Hibernate를 구성해야 한다. ë‹¹ì‹ ì€ ì ì–´ë„ ë‹¤ìŒ í”„ë¡œí¼í‹°ë“¤ 중 하나를 최소한으로 ì„¤ì •í• í•„ìš”ê°€ ìžˆì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr "Hibernate Datasource Properties"
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr "hibernate.connection.datasource"
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr "ë°ì´í„°ì†ŒìŠ¤ JNDI ì´ë¦„"
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr "hibernate.jndi.url"
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr "<emphasis>JNDI 프로바ì´ë”ì˜ URL</emphasis> (옵션)"
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr "hibernate.jndi.class"
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr "<emphasis>JNDI <literal>InitialContextFactory</literal>ì˜ í´ëž˜ìŠ¤ </emphasis> (옵션)"
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr "<emphasis>ë°ì´í„°ë² ì´ìŠ¤ 사용ìž</emphasis> (옵션)"
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr "<emphasis>ë°ì´í„°ë² ì´ìŠ¤ ì‚¬ìš©ìž íŒ¨ìŠ¤ì›Œë“œ</emphasis> (옵션)"
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr "다ìŒì€ 어플리케ì´ì…˜ 서버 ì œê³µ JNDI ë°ì´í„°ì†ŒìŠ¤ìš© ì˜ˆì œ <literal>hibernate.properties</literal> 파ì¼ì´ë‹¤:"
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr "JNDI datasource로부터 얻어진 JDBC ì»¤ë„¥ì…˜ë“¤ì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì„œë²„ì˜ ì»¨í…Œì´ë„ˆì— ì˜í•´ 관리ë˜ëŠ” 트랜ìžì…˜ë“¤ì— ìžë™ì 으로 ì°¸ì—¬í• ê²ƒì´ë‹¤."
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr "ìž„ì˜ì˜ 커넥션 프로í¼í‹°ë“¤ì€ 프로í¼í‹° ì´ë¦„ ì•žì— \"<literal>hibernate.connnection</literal>\"ì„ ì²¨ê°€í•˜ì—¬ 부여ë 수 있다. 예를 들어 ë‹¹ì‹ ì€ <literal>hibernate.connection.charSet</literal>ì„ ì‚¬ìš©í•˜ì—¬ <literal>charSet</literal>ì„ ì§€ì •í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr "ë‹¹ì‹ ì€ <literal>org.hibernate.connection.ConnectionProvider</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ êµ¬í˜„í•¨ìœ¼ë¡œì¨ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì–»ëŠ” ë‹¹ì‹ ìžì‹ ì˜ í”ŒëŸ¬ê·¸ì¸ ë°©ë„를 ì •ì˜í• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì€ <literal>hibernate.connection.provider_class</literal>를 ì„¤ì •í•˜ì—¬ 맞춤형 êµ¬í˜„ì„ ì„ íƒí• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr "ì„ íƒì ì¸ êµ¬ì„± 프로í¼í‹°ë“¤"
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr "실행 ì‹œì— Hibernateì˜ í–‰ìœ„ë¥¼ ì œì–´í•˜ëŠ” ë§Žì€ ë‹¤ë¥¸ 프로í¼í‹°ë“¤ì´ 존재한다. ëª¨ë“ ê²ƒì´ ì˜µì…˜ì´ì§€ë§Œ 합당한 ë””í´íŠ¸ ê°’ë“¤ì„ ê°–ëŠ”ë‹¤."
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr "<emphasis>ê²½ê³ : ì´ë“¤ 프로í¼í‹°ë“¤ 중 ëª‡ëª‡ì€ \"system-level\" ì „ìš©ì´ë‹¤.</emphasis> 시스템 ë ˆë²¨ 프로í¼í‹°ë“¤ì€ ì˜¤ì§ <literal>java -Dproperty=value</literal> ë˜ëŠ” <literal>hibernate.properties</literal>를 통해서만 ì„¤ì •ë 수 있다. ê·¸ê²ƒë“¤ì€ ìœ„ì— ì„¤ëª…ëœ ë‹¤ë¥¸ ê¸°ë²•ë“¤ì— ì˜í•´ ì„¤ì •ë 수 <emphasis>없다</emphasis>."
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr "Hibernate 구성 프로í¼í‹°ë“¤"
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr "íŠ¹ì • 관계형 ë°ì´í„°ë² ì´ìŠ¤ì— 최ì í™” ëœ SQLì„ ìƒì„±ì‹œí‚¤ëŠ” ê²ƒì„ Hibernateì—게 허용해주는 Hibernate <literal>Dialect</literal>ì˜ í´ëž˜ìŠ¤ëª…."
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>full.classname.of.Dialect</literal>"
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr "hibernate.show_sql"
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr "ëª¨ë“ SQL ë¬¸ìž¥ë“¤ì„ ì½˜ì†”ì— ê¸°ë¡í•œë‹¤. ì´ê²ƒì€ 로그 ì¹´í…Œê³ ë¦¬ <literal>org.hibernate.SQL</literal>를 <literal>debug</literal>ë¡œ ì„¤ì •í•˜ëŠ” ê²ƒì— ëŒ€í•œ í•˜ë‚˜ì˜ ë‹¤ë¥¸ 방법ì´ë‹¤."
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>true</literal> | <literal>false</literal>"
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr "hibernate.format_sql"
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr "로그와 콘솔 ì†ì— SQLì„ ê¹”ë”하게 프린트한다."
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr "hibernate.default_schema"
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr "ìƒì„±ëœ SQL ë‚´ì— ì£¼ì–´ì§„ schema/tablespace로서 수ì‹ì´ 없는 í…Œì´ë¸”ì´ë¦„ë“¤ì„ ìˆ˜ì‹í•œë‹¤."
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>SCHEMA_NAME</literal>"
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr "hibernate.default_catalog"
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr "주어진 SQL ë‚´ì— ì£¼ì–´ì§„ 카타ë¡ìœ¼ë¡œì„œ 수ì‹ì´ 없는 í…Œì´ë¸”ì´ë¦„ë“¤ì„ ìˆ˜ì‹í•œë‹¤."
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>CATALOG_NAME</literal>"
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr "hibernate.session_factory_name"
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr "<literal>SessionFactory</literal>는 ê·¸ê²ƒì´ ìƒì„±ëœ í›„ì— JNDI ë‚´ì—ì„œ ì´ ì´ë¦„ì— ìžë™ì 으로 ë°”ì¸ë“œ ë 것ì´ë‹¤."
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>jndi/composite/name</literal>"
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr "hibernate.max_fetch_depth"
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr "single-ended 연관관계들(one-to-one, many-to-one)ì˜ ê²½ìš°ì— outer join fetch íŠ¸ë¦¬ì˜ ìµœëŒ€ \"깊ì´\"를 ì„¤ì •í•œë‹¤. <literal>0</literal>ì€ ë””í´íŠ¸ outer join fetchingì„ ì‚¬ìš©ë¶ˆê°€ëŠ¥í•˜ê²Œ ë§Œë“ ë‹¤."
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>0</literal>ê³¼ <literal>3</literal> 사ì´ì˜ 값들ì´ê¶Œìž¥ëœë‹¤"
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr "hibernate.default_batch_fetch_size"
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr "ì—°ê´€ë“¤ì˜ Hibernate 배치 페ì¹ì— 대한 ë””í´íŠ¸ í¬ê¸°ë¥¼ ì„¤ì •í•œë‹¤."
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> 권장ë˜ëŠ” ê°’ë“¤ì€ <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr "hibernate.default_entity_mode"
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr "ì´ <literal>SessionFactory</literal>로부터 ì—´ë ¤ì§„ ëª¨ë“ ì„¸ì…˜ë“¤ì— ëŒ€í•´ 엔티티 í‘œí˜„ì„ ë””í´íŠ¸ 모드로 ì„¤ì •í•œë‹¤"
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr "hibernate.order_updates"
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr "ì—…ë°ì´íŠ¸ ì¤‘ì¸ í•ëª©ë“¤ì˜ 프ë¼ì´ë¨¸ë¦¬ 키 ê°’ì— ì˜í•´ SQL ì—…ë°ì´íŠ¸ë“¤ì´ 순서(ordering)지워지ë„ë¡ Hibernateì—게 ê°•ì œì‹œí‚¨ë‹¤. ì´ê²ƒì€ ê³ ë„ì˜ ë™ì‹œì„± 시스템들ì—ì„œ ë” ì ì€ íŠ¸ëžœìžì…˜ ë°ë“œë½(deadlock)들로 귀결ë 것ì´ë‹¤"
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr "hibernate.generate_statistics"
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr "ì´ìš© 가능하게 ë˜ë©´, Hibernate는 í¼í¬ë¨¼ìŠ¤ 튜ë‹ì— ìœ ìš©í•œ í†µê³„ë“¤ì„ ìˆ˜ì§‘í• ê²ƒì´ë‹¤."
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr "hibernate.use_identifer_rollback"
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr "ì´ìš© 가능하게 ë˜ë©´, ê°ì²´ê°€ ì‚ì œë ë•Œ ìƒì„±ëœ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì€ ë””í´íŠ¸ 값들로 ìž¬ì„¤ì •ë 것ì´ë‹¤."
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr "hibernate.use_sql_comments"
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr "ì´ìš© 가능하게 ë˜ë©´, Hibernate는 보다 쉬운 ë””ë²„ê¹…ì„ ìœ„í•´ SQL ë‚´ì— ì£¼ì„ë“¤ì„ ìƒì„±ì‹œí‚¬ 것ì´ë‹¤. ë””í´íŠ¸ëŠ” <literal>false</literal>."
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr "Hibernate JDBC ë° ì»¤ë„¥ì…˜ 프로í¼í‹°ë“¤"
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr "hibernate.jdbc.fetch_size"
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr "0 ì•„ë‹Œ ê°’ì€ JDBC fetch 사ì´ì¦ˆë¥¼ ê²°ì •í•œë‹¤(<literal>Statement.setFetchSize()</literal>ì„ í˜¸ì¶œí•œë‹¤ )."
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr "hibernate.jdbc.batch_size"
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr "0 ì•„ë‹Œ ê°’ì€ Hibernateì— ì˜í•œ JDBC2 배치 ì—…ë°ì´íŠ¸ì˜ ì‚¬ìš©ì„ ì´ìš© 가능하게 한다."
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>5</literal>와 <literal>30</literal> 사ì´ì˜ ê°’ë“¤ì´ ê¶Œìž¥ëœë‹¤"
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr "hibernate.jdbc.batch_versioned_data"
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr "ë‹¹ì‹ ì˜ JDBC ë“œë¼ì´ë²„ê°€ <literal>executeBatch()</literal>로부터 ì •í™•í•œ í–‰ ì¹´ìš´íŠ¸ë“¤ì„ ë°˜í™˜í• ê²½ìš°ì— ì´ í”„ë¡œí¼í‹°ë¥¼ <literal>true</literal>ë¡œ ì„¤ì •í•˜ë¼(대개 ì´ ì˜µì…˜ì„ ì‚¬ìš© 가능하게 하는 ê²ƒì´ ì•ˆì „í•˜ë‹¤). 그러면 Hibernate는 ìžë™ì 으로 ë²„ì „í™” ëœ ë°ì´í„°ì— 대해 배치화ëœ(batched) DMLì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. ë””í´íŠ¸ëŠ” <literal>false</literal>."
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr "hibernate.jdbc.factory_class"
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr "맞춤형 <literal>Batcher</literal>를 ì„ íƒí•œë‹¤. ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì€ ì´ êµ¬ì„± 프로í¼í‹°ë¥¼ 필요로 하지 ì•Šì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr "hibernate.jdbc.use_scrollable_resultset"
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr "Hibernateì— ì˜í•œ JDBC2 스í¬ë¡¤ 가능한 ê²°ê³¼ì…‹ë“¤ì˜ ì‚¬ìš©ì„ ê°€ëŠ¥í•˜ê²Œ 해준다. ì´ í”„ë¡œí¼í‹°ëŠ” 사용ìžê°€ ì œê³µí•œ JDBCì»¤ë„¥ì…˜ë“¤ì„ ì‚¬ìš©í• ë•Œì—만 필수ì ì´ê³ , ê·¸ ë°–ì˜ ê²½ìš° Hibernate는 커넥션 메타ë°ì´í„°ë¥¼ 사용한다."
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr "hibernate.jdbc.use_streams_for_binary"
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr "<literal>binary</literal> ë˜ëŠ” <literal>serializable</literal> íƒ€ìž…ë“¤ì„ JDBCë¡œ 기ë¡í•˜ê³ /JDBC로부터 <literal>binary</literal> ë˜ëŠ” <literal>serializable</literal> íƒ€ìž…ë“¤ì„ ì½ì–´ë“¤ì¼ ë•Œ ìŠ¤íŠ¸ë¦¼ë“¤ì„ ì‚¬ìš©í•œë‹¤(시스템-ë ˆë²¨ 프로í¼í‹°)."
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr "hibernate.jdbc.use_get_generated_keys"
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr "insert í›„ì— ê³ ìœ í•˜ê²Œ ìƒì„±ëœ í‚¤ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal>ì˜ ì‚¬ìš©ì„ ì´ìš© 가능하ë„ë¡ ë§Œë“ ë‹¤. JDBC3+ ë“œë¼ì´ë²„와 JRE1.4+를 필요로 í•˜ê³ , ë‹¹ì‹ ì˜ ë“œë¼ì´ë²„ê°€ Hibernate ì‹ë³„ìž ìƒì„±ìžë“¤ì— ë¬¸ì œê°€ ìžˆì„ ê²½ìš°ì— falseë¡œ ì„¤ì •í•˜ë¼. ë””í´íŠ¸ë¡œ 커넥션 메타 ë°ì´í„°ë¥¼ 사용하여 ë“œë¼ì´ë²„ ê°€ìš©ì„±ë“¤ì„ ê²°ì •í•˜ë ¤ê³ ì‹œë„하ë¼."
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>true|false</literal>"
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr "hibernate.connection.provider_class"
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr "Hibernateì— JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì œê³µí•˜ëŠ” 맞춤형 <literal>ConnectionProvider</literal>ì˜ í´ëž˜ìŠ¤ëª…."
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr "hibernate.connection.isolation"
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr "JDBC transaction isolation ë ˆë²¨ì„ ì„¤ì •í•œë‹¤. ì˜ë¯¸ìžˆëŠ” 값들로 <literal>java.sql.Connection</literal>ì„ ì²´í¬í•˜ì§€ë§Œ ëŒ€ë¶€ë¶„ì˜ ë°ì´í„°ë² ì´ìŠ¤ë“¤ì´ ëª¨ë“ ê²©ë¦¬(isolate) ë ˆë²¨ë“¤ì„ ì§€ì›í•˜ì§€ ì•ŠìŒì„ 노트하ë¼."
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>1, 2, 4, 8</literal>"
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr "hibernate.connection.autocommit"
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr "JDBC í’€ë§ëœ ì»¤ë„¥ì…˜ë“¤ì— ëŒ€í•´ ìžë™ì»¤ë°‹ì„ ì´ìš© 가능하ë„ë¡ í•œë‹¤(권장ë˜ì§€ ì•ŠìŒ)."
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr "hibernate.connection.release_mode"
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr "Hibernateê°€ JDBC ì»¤ë„¥ì…˜ë“¤ì„ í•´ì œí•˜ê²Œ ë ì‹œì ì„ ì§€ì •í•œë‹¤. ë””í´íŠ¸ë¡œ í•œ ê°œì˜ JDBC ì»¤ë„¥ì…˜ì€ ê·¸ ì„¸ì…˜ì´ ëª…ì‹œì 으로 닫히거나 ì—°ê²°í•´ì œë˜ê¸° ì „ê¹Œì§€ ë³´ê´€ëœë‹¤. 어플리케ì´ì…˜ 트랜ìžì…˜ 서버 JTA ë°ì´í„°ì†ŒìŠ¤ì˜ 경우, ë‹¹ì‹ ì€ ëª¨ë“ JDBC 호출 í›„ì— ì»¤ë„¥ì…˜ë“¤ì„ ê³¼ê°í•˜ê²Œ í•´ì œì‹œí‚¤ê¸° 위해 <literal>after_statement</literal>를 사용해야 한다. 비-JTA ì—°ê²°ì˜ ê²½ìš°, <literal>after_transaction</literal>ì„ ì‚¬ìš©í•˜ì—¬ ê°ê°ì˜ 트랜ìžì…˜ì˜ ëì—ì„œ ì»¤ë„¥ì…˜ë“¤ì„ í•´ì œì‹œí‚¤ëŠ” ê²ƒì´ ì¢…ì¢… ì˜ë¯¸ê°€ 있다. <literal>auto</literal>는 JTA ë° CMT 트랜ìžì…˜ ë°©ë„ë“¤ì˜ ê²½ìš°ì— <literal>after_statement</literal>를 ì„ íƒí•˜ê³ JDBC 트랜ìžì…˜ ë°©ë„ì— ëŒ€í•´ <literal>after_transaction</literal>를 ì„ íƒí• 것ì´ë‹¤."
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (ë””í´íŠ¸) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr "ì´ ì„¤ì •ì´ <literal>SessionFactory.openSession</literal>로부터 ë°˜í™˜ëœ <literal>Session</literal>들ì—만 ì˜í–¥ì„ 준다는 ì ì„ ë…¸íŠ¸í•˜ë¼. <literal>SessionFactory.getCurrentSession</literal>ì„ í†µí•´ 얻어진 <literal>Session</literal>ë“¤ì˜ ê²½ìš°, 사용하기 위해 êµ¬ì„±ëœ <literal>CurrentSessionContext</literal> êµ¬í˜„ì´ ê·¸ë“¤ <literal>Session</literal>ë“¤ì— ëŒ€í•œ ì—°ê²° í•´ì œë¥¼ ì œì–´í•œë‹¤. <xref linkend=\"architecture-current-session\"/>를 ë³´ë¼."
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr "hibernate.connection.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr "JDBC 프로í¼í‹° <literal>propertyName</literal>ì„ <literal>DriverManager.getConnection()</literal>ì— ì „ë‹¬í•œë‹¤."
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr "hibernate.jndi.<emphasis><propertyName></emphasis>"
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr "<literal>propertyName</literal> 프로í¼í‹°ë¥¼ JNDI <literal>InitialContextFactory</literal>ì— ì „ë‹¬í•œë‹¤."
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr "Hibernate Cache 프로í¼í‹°ë“¤"
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr "hibernate.cache.provider_class"
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr "맞춤형 <literal>CacheProvider</literal>ì˜ í´ëž˜ìŠ¤ëª…."
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.CacheProvider</literal>"
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr "hibernate.cache.use_minimal_puts"
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr "ì½ê¸°ê°€ 매우 빈번한 경우ì—, 쓰기를 최소화 시키기 위해 second-level ìºì‹œ ì—°ì‚°ì„ ìµœì í™” 시킨다. ì´ ì„¤ì •ì€ Hibernate3ì—ì„œ í´ëŸ¬ìŠ¤í„°ë§ ëœ ìºì‹œë“¤ì— 가장 ìœ ìš©í•˜ê³ , Hibernate3ì—서는 í´ëŸ¬ìŠ¤í„°ë§ëœ ìºì‹œ êµ¬í˜„ë“¤ì— ëŒ€í•´ ë””í´íŠ¸ë¡œ ì´ìš© 가능하다."
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr "hibernate.cache.use_query_cache"
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr "ì§ˆì˜ ìºì‹œë¥¼ 가능하게 ë§Œë“ ë‹¤. 개별 질ì˜ë“¤ì€ ì—¬ì „ížˆ ìºì‹œ 가능한 것으로 ì„¤ì •ë˜ì–´ì•¼ 한다."
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr "hibernate.cache.use_second_level_cache"
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr "second-level ìºì‹œë¥¼ ì™„ì „ížˆ 사용 불가능하게 í•˜ëŠ”ë° ì‚¬ìš©ë 수 ìžˆê³ , ê·¸ê²ƒì€ <literal><cache></literal> ë§¤í•‘ì„ ì§€ì •í•˜ëŠ” í´ëž˜ìŠ¤ë“¤ì— 대해 ë””í´íŠ¸ë¡œ ì´ìš© 가능ì´ë‹¤."
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr "hibernate.cache.query_cache_factory"
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr "맞춤형 <literal>QueryCache</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ í´ëž˜ìŠ¤ëª…. ë””í´íŠ¸ëŠ” 미리 ë¹Œë“œëœ <literal>StandardQueryCache</literal>."
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.QueryCache</literal>"
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr "hibernate.cache.region_prefix"
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr "second-level ìºì‹œ ì˜ì— ì´ë¦„ë“¤ì— ì‚¬ìš©í• ì ‘ë‘ì–´."
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>prefix</literal>"
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr "hibernate.cache.use_structured_entries"
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr "ì¸ê°„ì—게 보다 ë” ì¹œìˆ™í•œ 형ì‹ìœ¼ë¡œ second-level ìºì‹œ ì†ì— ë°ì´í„°ë¥¼ ì €ìž¥í•˜ë„ë¡ Hibernateì—게 ê°•ì œì‹œí‚¨ë‹¤.."
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr "Hibernate 트랜ìžì…˜ 프로í¼í‹°ë“¤"
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr "hibernate.transaction.factory_class"
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr "Hibernate <literal>Transaction</literal> API ì— ì‚¬ìš©í• <literal>TransactionFactory</literal>ì˜ í´ëž˜ìŠ¤ ì´ë¦„.(ë””í´íŠ¸ëŠ” <literal>JDBCTransactionFactory</literal>)."
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr "jta.UserTransaction"
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr "어플리케ì´ì…˜ 서버로부터 JTA <literal>UserTransaction</literal>ì„ ì–»ê¸° 위해 <literal>JTATransactionFactory</literal>ì— ì˜í•´ 사용ë˜ëŠ” JNDI ì´ë¦„."
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr "hibernate.transaction.manager_lookup_class"
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr "<literal>TransactionManagerLookup</literal>ì˜ í´ëž˜ìŠ¤ëª…- JVM ë ˆë²¨ì˜ ìºì‹±ì´ ì´ìš© ê°€ëŠ¥í• ë•Œ ë˜ëŠ” JTA 환경ì—ì„œ hilo generator를 ì‚¬ìš©í• ë•Œ 필요하다."
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr "hibernate.transaction.flush_before_completion"
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "ë§Œì¼ ì‚¬ìš©ê°€ëŠ¥í•˜ë„ë¡ ë˜ë©´, ì„¸ì…˜ì€ íŠ¸ëžœìžì…˜ì˜ before completion 단계 ë™ì•ˆì— ìžë™ì 으로 flush ë 것ì´ë‹¤. 빌드ë˜ì–´ 있는 ìžë™ì ì¸ ì„¸ì…˜ 컨í…스트 관리가 ì„ í˜¸ë˜ëŠ”ë°, <xref linkend=\"architecture-current-session\"/>를 ë³´ë¼."
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr "hibernate.transaction.auto_close_session"
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "ë§Œì¼ ì‚¬ìš©ê°€ëŠ¥í† ë¡ í•˜ë©´, after completion 단계 ë™ì•ˆì— ì„¸ì…˜ì´ ìžë™ì 으로 닫혀질 것ì´ë‹¤. (CMTì— ëŒ€í•´ Hibernate를 ì‚¬ìš©í• ë•Œ 매우 ìœ ìš©í•˜ë‹¤.)"
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr "여러가지 프로í¼í‹°ë“¤"
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr "hibernate.current_session_context_class"
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr "\"현재\" <literal>Session</literal>ì˜ ì˜ì—화를 위한 í•˜ë‚˜ì˜ (맞춤) ë°©ë„를 ì œê³µí•œë‹¤. 빌드ë˜ì–´ 있는 ë°©ë„ë“¤ì— ëŒ€í•œ 추가 ì •ë³´ëŠ” <xref linkend=\"architecture-current-session\"/>를 ë³´ë¼."
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr "hibernate.query.factory_class"
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr "Chooses the HQL 파서 êµ¬í˜„ì„ ì„ íƒí•œë‹¤."
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr "hibernate.query.substitutions"
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr "Hibernate 질ì˜ë“¤ ë‚´ì˜ í† í°ë“¤ë¡œë¶€í„° SQL í† í°ë“¤ë¡œì˜ 매핑 (예를 들어 í† í°ë“¤ì€ 함수 ì´ë¦„ ë˜ëŠ” 리터럴 ì´ë¦„ì¼ ìˆ˜ 있다)."
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr "hibernate.hbm2ddl.auto"
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr "<literal>SessionFactory</literal>ê°€ ìƒì„±ë ë•Œ, ìžë™ì 으로 ìœ íš¨ì„±ì„ ê²€ì‚¬í•˜ê±°ë‚˜ schema DDLì„ ë°ì´í„°ë² ì´ìŠ¤ë¡œ 내보내기 한다. <literal>create-drop</literal>ì˜ ê²½ìš°, <literal>SessionFactory</literal>ê°€ 명시ì 으로 닫혀질 ë•Œ ë°ì´í„°ë² ì´ìŠ¤ 스키마가 ë“œë¡ë 것ì´ë‹¤."
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr "<emphasis role=\"strong\">예.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr "hibernate.cglib.use_reflection_optimizer"
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr "런타임 reflection ëŒ€ì‹ ì— CGLIBì˜ ì‚¬ìš©ì„ ê°€ëŠ¥í•˜ë„ë¡ ë§Œë“ ë‹¤(시스템 ë ˆë²¨ 프로í¼í‹°). Reflectionì€ ë¬¸ì œê°€ ë°œìƒí• ì‹œì— ë•Œë•Œë¡œ ìœ ìš©í• ìˆ˜ ìžˆê³ , ë‹¹ì‹ ì´ optimizer를 사용하지 ì•Šì„ ê²½ìš°ì¡°ì°¨ë„ Hibernate는 í•ìƒ 필요로 í•¨ì„ ìœ ì˜í•˜ë¼. ë‹¹ì‹ ì€ <literal>hibernate.cfg.xml</literal> ì†ì— ì´ í”„ë¡œí¼í‹°ë¥¼ ì„¤ì •í• ìˆ˜ 없다."
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr "SQL Dialects"
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr "ë‹¹ì‹ ì€ í•ìƒ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 위해 <literal>hibernate.dialect</literal> 프로í¼í‹°ë¥¼ ì •í™•í•œ <literal>org.hibernate.dialect.Dialect</literal> 서브í´ëž˜ìŠ¤ë¡œ ì„¤ì •í•´ì•¼ 한다. ë§Œì¼ ë‹¹ì‹ ì´ dialect를 ì§€ì •í• ê²½ìš°, ë‹¹ì‹ ì´ í”„ë¡œí¼í‹°ë“¤ì„ 수작업으로 ì§€ì •í•˜ëŠ” ë…¸ë ¥ì„ ì ˆì•½í•˜ë„ë¡ Hibernate는 ìœ„ì— ì—´ê±°ëœ ë‹¤ë¥¸ 프로í¼í‹°ë“¤ 중 ëª‡ëª‡ì— ëŒ€í•´ ì˜ë¯¸ìžˆëŠ” ë””í´íŠ¸ë“¤ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤."
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr "RDBMS"
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr "Dialect"
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr "<entry>DB2</entry>"
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr "org.hibernate.dialect.DB2Dialect"
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr "DB2 AS/400"
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr "org.hibernate.dialect.DB2400Dialect"
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr "DB2 OS390"
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr "org.hibernate.dialect.DB2390Dialect"
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr "PostgreSQL"
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr "org.hibernate.dialect.PostgreSQLDialect"
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr "MySQL"
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr "org.hibernate.dialect.MySQLDialect"
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr "MySQL with InnoDB"
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr "org.hibernate.dialect.MySQLInnoDBDialect"
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr "MySQL with MyISAM"
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr "org.hibernate.dialect.MySQLMyISAMDialect"
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr "Oracle (any version)"
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr "org.hibernate.dialect.OracleDialect"
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr "Oracle 9i/10g"
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr "org.hibernate.dialect.Oracle9Dialect"
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr "Sybase"
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr "org.hibernate.dialect.SybaseDialect"
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr "Sybase Anywhere"
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr "org.hibernate.dialect.SybaseAnywhereDialect"
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr "Microsoft SQL Server"
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr "org.hibernate.dialect.SQLServerDialect"
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr "SAP DB"
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr "org.hibernate.dialect.SAPDBDialect"
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr "Informix"
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr "org.hibernate.dialect.InformixDialect"
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr "HypersonicSQL"
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr "org.hibernate.dialect.HSQLDialect"
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr "Ingres"
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr "org.hibernate.dialect.IngresDialect"
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr "Progress"
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr "org.hibernate.dialect.ProgressDialect"
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr "Mckoi SQL"
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr "org.hibernate.dialect.MckoiDialect"
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr "Interbase"
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr "org.hibernate.dialect.InterbaseDialect"
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr "Pointbase"
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr "org.hibernate.dialect.PointbaseDialect"
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr "FrontBase"
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr "org.hibernate.dialect.FrontbaseDialect"
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr "Firebird"
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr "org.hibernate.dialect.FirebirdDialect"
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr "Outer Join Fetching"
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ê°€ ANSI, Oracle, ë˜ëŠ” Sybase 스타ì¼ì˜ outer joinë“¤ì„ ì§€ì›í• 경우, <emphasis>outer join fetching</emphasis>ì€ (ë°ì´í„°ë² ì´ìŠ¤ ê·¸ ìžì²´ì— ì˜í•´ 보다 ë” ë§Žì€ ìž‘ì—…ì´ ìˆ˜í–‰ë˜ëŠ” 비용으로) ë°ì´í„°ë² ì´ìŠ¤ë¡œì˜ ê·¸ë¦¬ê³ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„°ì˜ ë¼ìš´ë“œ íŠ¸ë¦½ë“¤ì˜ ê°œìˆ˜ë¥¼ ì œí•œí•¨ìœ¼ë¡œì¨ ì¢…ì¢… í¼í¬ë¨¼ìŠ¤ë¥¼ ì¦ê°€ì‹œí‚¬ 것ì´ë‹¤. Outer join fetchingì€ many-to-one, one-to-many, many-to-many,one-to-one ì—°ê´€ê´€ê³„ë“¤ì´ ì— ì˜í•´ ì—°ê²°ëœ ê°ì²´ë“¤ì˜ ì „ì²´ 그래프가 í•˜ë‚˜ì˜ SQL <literal>SELECT</literal> ì†ì—ì„œ 검색ë˜ê²Œë” 허용해준다."
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr "Outer join fetchingì€ hibernate.max_fetch_depth 프로í¼í‹°ë¥¼ <literal>0</literal>으로 ì„¤ì •í•¨ìœ¼ë¡œì¨ <emphasis>ì „ì—ì 으로</emphasis> 사용 불가능하게 í• ìˆ˜ 있다. <literal>1</literal> ì´ìƒì˜ ê°’ì„ ì„¤ì •í•˜ëŠ” ê²ƒì€ <literal>fetch=\"join\"</literal>으로 매핑ë˜ì—ˆë˜ ëª¨ë“ one-to-one ë° many-to-one ì—°ê´€ê´€ê³„ë“¤ì— ëŒ€í•´ outer join fetchingì„ ì‚¬ìš© 가능하ë„ë¡ ë§Œë“ ë‹¤."
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "추가 ì •ë³´ëŠ” <xref linkend=\"performance-fetching\"/>를 ë³´ë¼."
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr "Binary Streams"
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr "Oracleì€ JDBC ë“œë¼ì´ë²„ ë¡œ/부터 ì „ë‹¬ë˜ëŠ” <literal>byte</literal> ë°°ì—´ë“¤ì˜ í¬ê¸°ë¥¼ ì œí•œì‹œí‚¨ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ <literal>binary</literal> ë˜ëŠ” <literal>serializable</literal> íƒ€ìž…ì˜ ëŒ€í˜• ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우ì—, ë‹¹ì‹ ì€ <literal>hibernate.jdbc.use_streams_for_binary</literal>를 사용 가능하게 해야 í• ê²ƒì´ë‹¤. <emphasis>ì´ê²ƒì€ ì˜¤ì§ ì‹œìŠ¤í…œ ë ˆë²¨ ì„¤ì •ì´ë‹¤.</emphasis>"
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr "Second-level ìºì‹œì™€ query ìºì‹œ"
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr "<literal>hibernate.cache</literal> ì ‘ë‘ì–´ê°€ ë¶™ì€ í”„ë¡œí¼í‹°ë“¤ì€ Hibernateì— ëŒ€í•´ 프로세스 ë˜ëŠ” í´ëŸ¬ìŠ¤í„° ë²”ìœ„ì˜ ë‘ ë²ˆì§¸ ë ˆë²¨ ìºì‹œ ì‹œìŠ¤í…œì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤. ìƒì„¸í•œ ê²ƒì€ <xref linkend=\"performance-cache\"/>를 ë³´ë¼."
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr "Query Language 치환"
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr "ë‹¹ì‹ ì€ <literal>hibernate.query.substitutions</literal>ì„ ì‚¬ìš©í•˜ì—¬ 새로운 Hibernate ì§ˆì˜ í† í°ë“¤ì„ ì •ì˜í• 수 있다. 예를 들어:"
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr "hibernate.query.substitutions true=1, false=0"
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr "ì€<literal>true</literal>와 <literal>false</literal> í† í°ë“¤ì´ ìƒì„±ëœ SQL ë‚´ì—ì„œ ì •ìˆ˜ 리터럴들로 번ì—ë˜ë„ë¡ ê°•ì œí• ê²ƒì´ë‹¤."
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr "hibernate.query.substitutions toLowercase=LOWER"
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr "ì€ SQL <literal>LOWER</literal> function 함수 ì´ë¦„ì„ ë³€ê²½í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해 줄 것ì´ë‹¤"
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr "Hibernate 통계"
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>hibernate.generate_statistics</literal>를 사용 가능하ë„ë¡ í• ê²½ìš°, Hibernate는 <literal>SessionFactory.getStatistics()</literal>를 통해 ê°€ë™ ì¤‘ì¸ ì‹œìŠ¤í…œì„ íŠœë‹í• ë•Œ ìœ ìš©í•œ ë§Žì€ í†µê³„ë“¤ì„ ë…¸ì¶œì‹œí‚¬ 것ì´ë‹¤. Hibernate는 심지어 JMX를 통해 ì´ë“¤ í†µê³„ë“¤ì„ ë…¸ì¶œì‹œí‚¤ë„ë¡ êµ¬ì„±ë 수 있다. 추가 ì •ë³´ëŠ” <literal>org.hibernate.stats</literal>ì— ìžˆëŠ” ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì— 관한 Javadoc를 ì½ì–´ë¼."
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr "<title>로깅</title>"
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr "Hibernate는 Apache commons-logging를 사용하여 다양한 ì´ë²¤íŠ¸ë“¤ì„ 로그시킨다."
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr "commons-logging 서비스는 (ë§Œì¼ ë‹¹ì‹ ì´ classpath ë‚´ì— <literal>log4j.jar</literal>를 í¬í•¨í• 경우) Apache Log4jë¡œ ë˜ëŠ” (JDK1.4 ì´ìƒì˜ ë²„ì „ì—ì„œ 실행ë 경우) JDK 1.4 로깅으로 ì§ì ‘ ì¶œë ¥í• ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ <literal>http://jakarta.apache.org</literal>ì—ì„œ Log4j를 다운로드 í• ìˆ˜ 있다. Log4j를 사용하기 위해, ë‹¹ì‹ ì€ <literal>log4j.properties</literal> 파ì¼ì„ ë‹¹ì‹ ì˜ classpath ë‚´ì— ìœ„ì¹˜ì§€ìš¸ 필요가 ìžˆì„ ê²ƒì´ê³ , ì˜ˆì œ properties 파ì¼ì€ Hibernateì˜ <literal>src/</literal> ë””ë ‰í† ë¦¬ ë‚´ì— ë°°í¬ë˜ì–´ 있다."
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr "우리는 ë‹¹ì‹ ì´ Hibernateì˜ ë¡œê·¸ ë©”ì‹œì§€ë“¤ì— ìµìˆ™í•´ì§€ê¸°ë¥¼ ê°•ë ¥ížˆ 권장한다. ì½ê¸° 불가능하지 ì•Šê²Œë” ê°€ëŠ¥í•œ í•œ ìƒì„¸í•˜ê²Œ Hibernate 로그를 만들ë„ë¡ ë§Žì€ ìž‘ì—…ì´ í–‰í•´ì¡Œë‹¤. ê·¸ê²ƒì€ ë³¸ì§ˆì ì¸ ë¬¸ì œë˜ì§€ê¸° 장치ì´ë‹¤. 가장 í¥ë¯¸ë¡œìš´ 로그 ì¹´í…Œê³ ë¦¬ë“¤ì´ ë‹¤ìŒì— 있다:"
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr "Hibernate 로그 ì¹´í…Œê³ ë¦¬ë“¤"
+
+#: index.docbook:1219
+msgid "Category"
+msgstr "ì¹´í…Œê³ ë¦¬"
+
+#: index.docbook:1220
+msgid "Function"
+msgstr "<entry>기능</entry>"
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr "org.hibernate.SQL"
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr "SQL DML ë¬¸ìž¥ë“¤ì´ ì‹¤í–‰ë ë•Œ 그것들 모ë‘를 로그 시킨다"
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr "org.hibernate.type"
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr "ëª¨ë“ JDBC 파ë¼ë¯¸í„°ë“¤ì„ 로그시킨다"
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr "org.hibernate.tool.hbm2ddl"
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr "SQL DDL ë¬¸ìž¥ë“¤ì´ ì‹¤í–‰ë ë•Œ 그것들 모ë‘를 로그 시킨다"
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr "org.hibernate.pretty"
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr "flush ì‹œì ì—ì„œ 세션과 ì—°ê´€ëœ ëª¨ë“ ì—”í‹°í‹°ë“¤(최대 20ê°œì˜ ì—”í‹°í‹°ë“¤)ì˜ ìƒíƒœë¥¼ 로그 시킨다"
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr "org.hibernate.cache"
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr "ëª¨ë“ second-level ìºì‹œ 액티비티를 로그시킨다"
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr "org.hibernate.transaction"
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr "트랜ìžì…˜ ê´€ë ¨ 액티비티를 로그 시킨다"
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr "org.hibernate.jdbc"
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr "ëª¨ë“ JDBC 리소스 ì·¨ë“ì„ ë¡œê·¸ 시킨다"
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr "org.hibernate.hql.ast.AST"
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr "ì§ˆì˜ íŒŒì‹± ë™ì•ˆì— HQL AST와 SQL AST를 로그시킨다"
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr "org.hibernate.secure"
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr "ëª¨ë“ JAAS 허가 ìš”ì²ë“¤ì„ 로그시킨다"
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr "org.hibernate"
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr "ëª¨ë“ ê²ƒì„ ë¡œê·¸ì‹œí‚¨ë‹¤(ë§Žì€ ì •ë³´ì´ì§€ë§Œ, ë¬¸ì œí•´ê²°ì— ë§¤ìš° ìœ ìš©í•˜ë‹¤)"
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr "Hibernateë¡œ 어플리케ì´ì…˜ë“¤ì„ ê°œë°œí• ë•Œ, ë‹¹ì‹ ì€ ê±°ì˜ í•ìƒ <literal>org.hibernate.SQL</literal> ì¹´í…Œê³ ë¦¬ì— ëŒ€í•´ ì´ìš© 가능한 <literal>debug</literal> 모드로 작업하거나, 다른 방법으로 <literal>hibernate.show_sql</literal> 프로í¼í‹°ë¥¼ ì´ìš©ê°€ëŠ¥í•˜ê²Œ 하여 작업해야 í• ê²ƒì´ë‹¤."
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr "<literal>NamingStrategy</literal> 구현하기"
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr "<literal>org.hibernate.cfg.NamingStrategy</literal> ì¸í„°íŽ˜ì´ìŠ¤ëŠ” ë°ì´í„°ë² ì´ìŠ¤ ê°ì²´ë“¤ê³¼ 스키마 ìš”ì†Œë“¤ì— ëŒ€í•œ \"네ì´ë° 표준\"ì„ ì§€ì •í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr "ë‹¹ì‹ ì€ Java ì‹ë³„ìžë“¤ë¡œë¶€í„° ë°ì´í„°ë² ì´ìŠ¤ ì‹ë³„ìžë“¤ì„ ìžë™ì 으로 ìƒì„±ì‹œí‚¤ê±°ë‚˜ 매핑 파ì¼ì— 주어진 \"논리ì \" 컬럼과 í…Œì´ë¸” ì´ë¦„ë“¤ì„ \"물리ì \" í…Œì´ë¸”ê³¼ 컬럼 ì´ë¦„들로 ìžë™ì 으로 처리하는 ê·œì¹™ë“¤ì„ ì œê³µí• ìˆ˜ 있다. ì´ íŠ¹ì§•ì€ ë°˜ë³µë˜ëŠ” ìž¡ìŒ(예를 들어 <literal>TBL_</literal>ì ‘ë‘어들)ì„ ì œê±°í•¨ìœ¼ë¡œì¨, 매핑 ë¬¸ì„œì˜ ë§ë§Žì€ ìž¥í™©í•¨ì„ ê°ì†Œì‹œí‚¤ë„ë¡ ë„와준다. Hibernateì— ì˜í•´ 사용ë˜ëŠ” ë””í´íŠ¸ ë°©ë„는 아주 ìž‘ì€ ìž‘í’ˆì´ë‹¤."
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr "ë‹¹ì‹ ì€ ë§¤í•‘ë“¤ì„ ì¶”ê°€í•˜ê¸° ì´ì „ì— <literal>Configuration.setNamingStrategy()</literal>를 í˜¸ì¶œí•¨ìœ¼ë¡œì¨ ë‹¤ë¥¸ ë°©ë„를 ì§€ì •í• ìˆ˜ 있다:"
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal>는 ì–´ë–¤ 어플리케ì´ì…˜ë“¤ì— 대한 ìœ ìš©í•œ 시작ì ì¼ ìˆ˜ 있는 미리 ë¹Œë“œëœ ë°©ë„ì´ë‹¤."
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr "XML 구성 파ì¼"
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr "êµ¬ì„±ì— ëŒ€í•œ 다른 ì ‘ê·¼ë²•ì€ <literal>hibernate.cfg.xml</literal>ë¡œ ëª…ëª…ëœ íŒŒì¼ ì†ì— ì „ì²´ êµ¬ì„±ì„ ì§€ì •í•˜ëŠ” 것ì´ë‹¤. ì´ íŒŒì¼ì€ <literal>hibernate.properties</literal> 파ì¼ì— 대한 대용물로서 사용ë 수 있거나, ë§Œì¼ ë‘˜ 다 ì¡´ìž¬í• ê²½ìš°ì— í”„ë¡œí¼í‹°ë“¤ì„ ì¤‘ë³µì •ì˜í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다."
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr "XML 구성 파ì¼ì€ ë””í´íŠ¸ë¡œ ë‹¹ì‹ ì˜ <literal>CLASSPATH</literal>ì˜ ë£¨íŠ¸ì— ì¡´ìž¬í•˜ëŠ” ê²ƒì´ ê¸°ëŒ€ëœë‹¤. 다ìŒì€ ì˜ˆì œì´ë‹¤:"
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr "ë‹¹ì‹ ì´ ë³¼ 수 있듯ì´, ì´ ì ‘ê·¼ë²•ì˜ ìž¥ì ì€ êµ¬ì„±ì— ëŒ€í•œ 매핑 íŒŒì¼ ì´ë¦„ë“¤ì„ êµ¬ì²´í™” 시키는 것ì´ë‹¤. <literal>hibernate.cfg.xml</literal>ì€ ë˜í•œ ë‹¹ì‹ ì´ Hibernate ìºì‹œë¥¼ 튜ë‹í•´ì•¼í• ë•Œ 보다 편리하다. <literal>hibernate.properties</literal> ë˜ëŠ” <literal>hibernate.cfg.xml</literal> 중 ì–´ëŠ ê²ƒì„ ì‚¬ìš©í•˜ëŠ”ê°€ëŠ” ë‹¹ì‹ ì˜ ì„ íƒì´ë‹¤. XML êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ëŠ” ìœ„ì— ì–¸ê¸‰ëœ ì´ì ë“¤ì„ ì œì™¸í•˜ë©´ 둘다 ê°™ì€ ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr "Hibernate 구성으로, Hibernate를 시작하는 ê²ƒì€ ë‹¤ìŒê³¼ ê°™ì´ ê°„ë‹¨í•˜ë‹¤"
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr "ë‹¹ì‹ ì€ ë‹¤ìŒì„ 사용하여 다른 XML 구성 파ì¼ì„ 찾아낼 수 있다"
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr "J2EE 어플리케ì´ì…˜ 서버 통합"
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr "Hibernate는 J2EE ì¸í”„ë¼ìŠ¤íŠ¸ëŸì²˜ì— 대한 ë‹¤ìŒ í†µí•© ì ë“¤ì„ ê°–ê³ ìžˆë‹¤:"
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr "<emphasis>Container-managed datasources</emphasis>: Hibernate는 컨테ì´ë„ˆì— ì˜í•´ 관리ë˜ëŠ” JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì‚¬ìš©í• ìˆ˜ ìžˆê³ JNDI를 통해 ì œê³µëœë‹¤. 대개 JTA 호환 <literal>TransactionManager</literal>와 <literal>ResourceManager</literal>는 트랜ìžì…˜ 관리(CMT), 특히 몇몇 ë°ì´í„°ì†ŒìŠ¤ë“¤ì„ 가로질러 ë¶„ì‚°ëœ íŠ¸ëžœìžì…˜ 핸들ë§ì„ 처리한다. ë¬¼ë¡ ë‹¹ì‹ ì€ ë˜í•œ 프로그램 ìƒìœ¼ë¡œ 트랜ìžì…˜ ê²½ê³„ë“¤ì„ í•œì •í• ìˆ˜ë„ ìžˆê±°ë‚˜(BMT) ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì½”ë“œê°€ ì´ì‹ì„±ì„ ìœ ì§€í•˜ë„ë¡ ì´ê²ƒì— 대한 ì„ íƒì ì¸ Hibernate <literal>Transaction</literal> API를 ì‚¬ìš©í•˜ê³ ìž ì›í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr "<emphasis>ìžë™ì ì¸ JNDI ë°”ì¸ë”©</emphasis>: Hibernate는 시작 í›„ì— ê·¸ê²ƒì˜ <literal>SessionFactory</literal>를 JNDIì— ë°”ì¸ë“œ 시킬 수 있다."
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr "<emphasis>JTA Session ë°”ì¸ë”©</emphasis>: Hibernate <literal>Session</literal>ì€ JTA 트랜ìžì…˜ë“¤ì˜ ì˜ì—(scope)ì— ìžë™ì 으로 ë°”ì¸ë“œ 시킬 ìˆ˜ë„ ìžˆë‹¤. 간단하게 JNDI로부터 <literal>SessionFactory</literal>를 ë£©ì—…í•˜ê³ í˜„ìž¬ <literal>Session</literal>ì„ ì–»ì–´ë¼. Hibernateë¡œ 하여금 ë‹¹ì‹ ì˜ JTA 트랜ìžì…˜ì´ 완료ë ë•Œ <literal>Session</literal>ì„ flushì‹œí‚¤ê³ ë‹«ëŠ” ê²ƒì„ ì²˜ë¦¬í•˜ë„ë¡ í•˜ë¼. 트랜ìžì…˜ 경계 êµ¬ë¶„ì€ ì„ ì–¸ì (CMT)ì´ê±°ë‚˜ 프로그래ë°ì ((BMT/UserTransaction))ì´ë‹¤."
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr "<emphasis>JMX 배치</emphasis>: ë§Œì¼ ë‹¹ì‹ ì´ JMX ê°€ìš©ì„±ì´ ìžˆëŠ” 어플리케ì´ì…˜ 서버(예를 들면 JBoss AS)를 ê°–ê³ ìžˆë‹¤ë©´, ë‹¹ì‹ ì€ Hibernate를 í•˜ë‚˜ì˜ managed MBean으로서 배치하는 ê²ƒì„ ì„ íƒí• 수 있다. ì´ê²ƒì€ <literal>Configuration</literal>으로부터 ë‹¹ì‹ ì˜ <literal>SessionFactory</literal>를 빌드 시키는 í•œ ì¤„ì˜ ì‹œìž‘ 코드를 ì ˆì•½í•´ì¤€ë‹¤. 컨테ì´ë„ˆëŠ” ë‹¹ì‹ ì˜ <literal>HibernateService</literal>를 ì‹œìž‘í• ê²ƒì´ê³ , ë˜í•œ ì´ìƒì 으로 서비스 ì˜ì¡´ì„±ë“¤ì„ ì²˜ë¦¬í• ê²ƒì´ë‹¤(ë°ì´í„°ì†ŒìŠ¤ëŠ” Hibernateê°€ 시작ë˜ê¸° ì „ì— ì´ìš© 가능해야 한다)."
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr "ë‹¹ì‹ ì˜ í™˜ê²½ì— ë”°ë¼, ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ 서버가 \"connection containment(ì—°ê²° 봉쇄)\" 예외ìƒí™©ë“¤ì„ ë³´ì¼ ê²½ìš°ì— êµ¬ì„± 옵션 <literal>hibernate.connection.aggressive_release</literal>를 trueë¡œ ì„¤ì •í•´ì•¼ ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr "트랜ìžì…˜ ë°©ë„ êµ¬ì„±"
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr "Hibernate <literal>Session</literal> API는 ë‹¹ì‹ ì˜ ì•„ì¹´í…처 ë‚´ì—ì„œ ìž„ì˜ì˜ 트랜ìžì…˜ ê´€í• ì‹œìŠ¤í…œì— ë…립ì ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ Hibernateë¡œ 하여금 커넥션 í’€ì„ í†µí•´ ì§ì ‘ JDBC를 사용하ë„ë¡ ê°•ì œí• ê²½ìš°, ë‹¹ì‹ ì€ JDBC API를 호출하여 ë‹¹ì‹ ì˜ íŠ¸ëžœìžì…˜ì„ ì‹œìž‘í•˜ê³ ë낼 수 있다. ë§Œì¼ ë‹¹ì‹ ì´ J2EE 어플리케ì´ì…˜ 서버를 실행 중ì´ë¼ë©´, ë‹¹ì‹ ì€ í•„ìš”í• ë•Œ bean-managed 트랜ìžì…˜ë“¤ì„ ì‚¬ìš©í•˜ê³ JTA API와 <literal>UserTransaction</literal>ì„ í˜¸ì¶œí•˜ê³ ìž ì›í• 수 있다."
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr "ì´ë“¤ ë‘ ê°œì˜ (ê·¸ë¦¬ê³ ë‹¤ë¥¸) 환경들ì—ì„œ ë‹¹ì‹ ì˜ ì½”ë“œì— ì´ì‹ì„±ì„ ìœ ì§€í•˜ê¸° 위해 우리는 기본 ì‹œìŠ¤í…œì„ í¬ìž¥í•˜ê³ ì€í시키는 ì„ íƒì ì¸ Hibernate <literal>Transaction</literal> API를 권장한다. ë‹¹ì‹ ì€ Hibernate 구성 프로í¼í‹° <literal>hibernate.transaction.factory_class</literal>를 사용하여 <literal>Transaction</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 íŒ©í† ë¦¬ í´ëž˜ìŠ¤ë¥¼ ì§€ì •í•´ì•¼ 한다."
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr "세 ê°œì˜ í‘œì¤€(미리 만들어진) ì„ íƒë“¤ì´ 존재한다:"
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr "org.hibernate.transaction.JDBCTransactionFactory"
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ (JDBC) 트랜ìžì…˜ë“¤ì—게 위임시킨다(ë””í´íŠ¸)"
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr "org.hibernate.transaction.JTATransactionFactory"
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr "ê¸°ì¡´ì˜ íŠ¸ëžœìžì…˜ì´ ì´ ì»¨í…스트(예를 들면 EJB session bean 메소드) ë‚´ì—ì„œ 진행 ì¤‘ì¼ ê²½ìš°ì— container-managed transactionì—게 ìœ„ìž„ì‹œí‚¤ê³ , ê·¸ ë°–ì˜ ê²½ìš° 새로운 트랜ìžì…˜ì´ 시작ë˜ê³ bean-managed transactionì´ ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr "org.hibernate.transaction.CMTTransactionFactory"
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr "container-managed JTA 트랜ìžì…˜ë“¤ì—게 위임시킨다"
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ìžì‹ ì˜ íŠ¸ëžœìžì…˜ ë°©ë„들(예를 들면 CORBA 트랜ìžì…˜ 서비스)ì„ ì •ì˜í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr "Hibernateì— ìžˆëŠ” 몇몇 특징들(예를 들면. second level ìºì‹œ, JTA를 가진 컨í…스트 ìƒì˜ 세션들, 기타.)ì€ ê´€ë¦¬ë˜ëŠ” 환경ì—ì„œ JTA <literal>TransactionManager</literal>ì— ëŒ€í•œ ì ‘ê·¼ì„ í•„ìš”ë¡œ 한다. 어플리케ì´ì…˜ 서버ì—ì„œ ë‹¹ì‹ ì€ Hibernateê°€ <literal>TransactionManager</literal>ì— ëŒ€í•œ 참조를 íšë“하는 ë°©ë²•ì„ ì§€ì •í•´ì•¼ 한다. 왜ëƒí•˜ë©´ J2EEê°€ í•œ ê°œì˜ ë©”ì»¤ë‹ˆì¦˜ì„ í‘œì¤€í™” ì‹œí‚¤ê³ ìžˆì§€ 않기 때문ì´ë‹¤:"
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr "JTA TransactionManagers"
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr "트랜ìžì…˜ íŒ©í† ë¦¬"
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr "어플리케ì´ì…˜ 서버"
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JBossTransactionManagerLookup"
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr "JBoss"
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr "Weblogic"
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr "WebSphere"
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr "WebSphere 6"
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr "org.hibernate.transaction.OrionTransactionManagerLookup"
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr "Orion"
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr "org.hibernate.transaction.ResinTransactionManagerLookup"
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr "Resin"
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JOTMTransactionManagerLookup"
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr "JOTM"
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr "org.hibernate.transaction.JOnASTransactionManagerLookup"
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr "JOnAS"
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr "org.hibernate.transaction.JRun4TransactionManagerLookup"
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr "JRun4"
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr "org.hibernate.transaction.BESTransactionManagerLookup"
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr "Borland ES"
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr "JNDI-bound <literal>SessionFactory</literal>"
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr "í•˜ë‚˜ì˜ JNDI ë°”ì¸ë“œëœ Hibernate <literal>SessionFactory</literal>는 ê·¸ íŒ©í† ë¦¬ì— ëŒ€í•œ 룩업과 새로운 <literal>Session</literal>ë“¤ì˜ ìƒì„±ì„ 단순화 시킬 수 있다. ì´ê²ƒì€ JNDI ë°”ì¸ë“œëœ <literal>Datasource</literal>ì— ê´€ë ¨ë˜ì–´ 있지 ì•Šê³ , 단순하게 둘 다 ë™ì¼í•œ ë ˆì§€ìŠ¤íŠ¸ë¦¬ë¥¼ 사용한다는 ì ì„ ë…¸íŠ¸í•˜ë¼!"
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>SessionFactory</literal>를 í•˜ë‚˜ì˜ JNDI namespaceì— ë°”ì¸ë“œ ì‹œí‚¤ê³ ìž ì›í• 경우, <literal>hibernate.session_factory_name</literal> 프로í¼í‹°ë¥¼ 사용하여 í•œ ê°œì˜ ì´ë¦„(예를 들면. <literal>java:hibernate/SessionFactory</literal>)ì„ ì§€ì •í•˜ë¼. ë§Œì¼ ì´ í”„ë¡œí¼í‹°ê°€ ìƒëžµë 경우, <literal>SessionFactory</literal>는 JNDIì— ë°”ì¸ë“œ ë˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. (ì´ê²ƒì€ ì½ê¸°-ì „ìš© JNDI ë””í´íŠ¸ êµ¬í˜„ì„ ê°€ì§„ 환경들, 예를 들면 Tomcatì—ì„œ 특히 ìœ ìš©í•˜ë‹¤.)"
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr "<literal>SessionFactory</literal>를 JNDIì— ë°”ì¸ë“œ 시킬 ë•Œ, Hibernate는 초기 컨í…스트를 초기화 시키기 위해 <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal>ì˜ ê°’ë“¤ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. ë§Œì¼ ê·¸ê²ƒë“¤ì´ ì§€ì •ë˜ì–´ 있지 ì•Šì„ ê²½ìš°, ë””í´íŠ¸ <literal>InitialContext</literal>ê°€ 사용ë 것ì´ë‹¤."
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr "Hibernate는 ë‹¹ì‹ ì´ <literal>cfg.buildSessionFactory()</literal>를 호출한 í›„ì— <literal>SessionFactory</literal>를 JNDI ë‚´ì— ìžë™ì 으로 위치지울 것ì´ë‹¤. ì´ê²ƒì€ ë‹¹ì‹ ì´ (ë‚˜ì¤‘ì— ë…¼ì˜ë˜ëŠ”) <literal>HibernateService</literal>를 가진 JMX 배치를 사용하지 않는 í•œ, ë‹¹ì‹ ì´ ì ì–´ë„ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì— ìžˆëŠ” ì–´ë–¤ 시작 코드 (ë˜ëŠ” ìœ í‹¸ë¦¬í‹° í´ëž˜ìŠ¤) ë‚´ì—ì„œ ì´ê²ƒì„ í˜¸ì¶œí• ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ JNDI <literal>SessionFactory</literal>를 ì‚¬ìš©í• ê²½ìš°, í•˜ë‚˜ì˜ EJB ë˜ëŠ” ì–´ë–¤ 다른 í´ëž˜ìŠ¤ëŠ” JNDI ë£©ì—…ì„ ì‚¬ìš©í•˜ì—¬ <literal>SessionFactory</literal>를 ì–»ì„ ìˆ˜ 있다."
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr "우리는 관리ë˜ëŠ” 환경들ì—ì„œ <literal>SessionFactory</literal>를 JNDIì— ë°”ì¸ë“œ ì‹œí‚¤ê³ ê·¸ ë°–ì˜ ê²½ìš°ì—는 í•˜ë‚˜ì˜ <literal>static</literal> ì‹±ê¸€í†¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ê¶Œìž¥í•œë‹¤. ì´ë“¤ ìƒì„¸ë¡œë¶€í„° ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ 코드를 ì€í시키기 위해, 우리는 ë˜í•œ <literal>HibernateUtil.getSessionFactory()</literal>ê³¼ ê°™ì€ í•˜ë‚˜ì˜ helper í´ëž˜ìŠ¤ ë‚´ì—ì„œ <literal>SessionFactory</literal>ì— ëŒ€í•œ ì‹¤ì œ 룩업 코드를 ì€í시키기를 권장한다. 그런 í´ëž˜ìŠ¤ëŠ” ë˜í•œ Hibernate를 시작하는 편리한 ë°©ë²•ìž„ì„ ë…¸íŠ¸í•˜ë¼— 1ìž¥ì„ ë³´ë¼."
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr "Current Session context management with JTA"
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr "ë‹¹ì‹ ìžì‹ ì˜ <literal>ThreadLocal</literal> ìœ í‹¸ë¦¬í‹°ë¥¼ ìž‘ë™ì‹œí‚¤ëŠ” ëŒ€ì‹ ì—, 우리는 ë˜í•œ Hibernate <literal>Session</literal>를 얻기 위해 <literal>SessionFactory</literal> ìƒì˜ <literal>getCurrentSession()</literal> 메소드 ì‚¬ìš©ì„ ê¶Œìž¥í•œë‹¤. <xref linkend=\"architecture-current-session\"/>현재 ì„¸ì…˜ë“¤ì— ê´€í•œ ë…¼ì˜ë¥¼ ë³´ë¼. <literal>\"jta\"</literal> 세션 컨í…스트를 ì‚¬ìš©í•˜ê³ ìžˆëŠ” 경우ì—, í˜„ìž¬ì˜ JTA 트랜ìžì…˜ìœ¼ë¡œ 시작ë˜ê³ ì—°ê´€ëœ Hibernate <literal>Session</literal>ì´ ì¡´ìž¬í•˜ì§€ ì•Šì„ ê²½ìš°, 우리는 JTA 트랜ìžì…˜ìœ¼ë¡œ 시작ë˜ê³ ì—°ê´€ë 것ì´ë‹¤. <literal>\"jta\"</literal> 컨í…스트ì—ì„œ <literal>getCurrentSession()</literal>를 통해 ê²€ìƒ‰ëœ <literal>Session</literal>ë“¤ì€ ê·¸ 트랜ìžì…˜ì´ 완료ë˜ê¸° ì „ì— ìžë™ì 으로 flushë 것ì´ê³ 트랜ìžì…˜ 완료 í›„ì— ë‹«í˜€ì§ˆ 것ì´ê³ , ê·¸ë¦¬ê³ ê°ê°ì˜ 문장 ë’¤ì— JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì ê·¹ì 으로 í•´ì œí!
• 것ì´ë‹¤. ì´ê²ƒì€ 그런 관리 사í•ë“¤ì— 대해 ì‚¬ìš©ìž ì½”ë“œë¥¼ 명료하게 ìœ ì§€ì‹œì¼œì„œ, ì—°ê´€ë˜ì–´ 있는 JTA 트랜ìžì…˜ì˜ ìƒëª…ì£¼ê¸°ì— ì˜í•´ <literal>Session</literal>ë“¤ì´ ê´€ë¦¬ë˜ë„ë¡ í—ˆìš©í•´ì¤€ë‹¤. ì´ê²ƒì€ 그런 관리 사í•ë“¤ì— 대해 ì‚¬ìš©ìž ì½”ë“œë¥¼ 명료하게 ìœ ì§€ì‹œì¼œì„œ, ì„¸ì…˜ì´ ì—°ê´€ë˜ì–´ 있는 JTA 트랜ìžì…˜ì˜ ìƒëª…ì£¼ê¸°ì— ì˜í•´ 관리ë˜ëŠ” ê²ƒì„ <literal>Session</literal>들ì—게 허용해준다. ë‹¹ì‹ ì˜ ì½”ë“œëŠ” <literal>Session</literal>들과 트랜ìžì…˜ë“¤ì„ 처리하는 가장 ì†ì‰¬ìš´ ë°©ë²•ì€ Hibernateì˜ ìžë™ì ì¸ \"현재\" <literal>Session</literal>ì´ë‹¤. <xref linkend=\"architecture-current-session\"/>current sessionsì— ê´€í•œ ë…¼ì˜ë¥¼ ë³´ë¼. <literal>\"jta\"</literal> 세션 컨í…스트를 사용하는 경우, í˜„ìž¬ì˜ JTA 트랜ìžì…˜ìœ¼ë¡œ 시작ë˜ê³ ì—°ê´€ëœ Hibernate <literal>Session</literal>ë“¤ì´ ì¡´ìž¬í•˜ì§€ ì•Šì„ ê²½ìš°, ë‹¹ì‹ ì´ <literal>sessionFactory.get!
CurrentSession()</literal>ì„ ì²˜ìŒ í˜¸ì¶œí• ë•Œ í•˜ë‚˜ì˜ ì„¸ì…˜ì´
í˜„ìž¬ì˜ JTA 트랜ìžì…˜ì— 대해 시작ë˜ê³ ì—°ê´€ë 것ì´ë‹¤. <literal>\"jta\"</literal> 컨í…스트ì—ì„œ <literal>getCurrentSession()</literal>ì„ í†µí•´ ê²€ìƒ‰ëœ <literal>Session</literal>ë“¤ì€ ê·¸ 트랜ìžì…˜ì´ 완료ë˜ê¸° ì „ì— ìžë™ì 으로 flushë 것ì´ê³ ê·¸ 트랜ìžì…˜ 완료들 í›„ì— ë‹«í˜€ì§ˆ 것ì´ê³ ê°ê°ì˜ 문장 í›„ì— JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì ê·¹ì 으로 í•´ì œí• ê²ƒì´ë‹¤. ì´ê²ƒì€ 그런 관리 사í•ë“¤ì— 대해 ì‚¬ìš©ìž ì½”ë“œë¥¼ 명료하게 ìœ ì§€ì‹œì¼œì„œ, ì—°ê´€ë˜ì–´ 있는 JTA 트랜ìžì…˜ì˜ ìƒëª…ì£¼ê¸°ì— ì˜í•´ <literal>Session</literal>ë“¤ì´ ê´€ë¦¬ë˜ë„ë¡ í—ˆìš©í•´ì¤€ë‹¤. ì´ê²ƒì€ 그런 관리 사í•ë“¤ì— 대해 ì‚¬ìš©ìž ì½”ë“œë¥¼ 명료하게 ìœ ì§€ì‹œì¼œì„œ, ì„¸ì…˜ì´ ì—°ê´€ë˜ì–´ 있는 JTA 트랜ìžì…˜ì˜ ìƒëª…ì£¼ê¸°ì— ì˜í•´ 관리ë˜ëŠ” ê²ƒì„ <literal>Session</literal>들ì—게 허용해준다. ë‹¹ì‹ ì˜ ì½”ë“œëŠ” 트랜ìžì…˜ ê²½ê³„ë“¤ì„ ì„¤ì •í•˜ëŠ”ë° <literal>UserTransaction</literal>ì„ í†µí•!
´ 프로그램 ìƒìœ¼ë¡œ JTA를 사용하거나, Hibernate <literal>Transaction</literal> API를 (ì´ì‹ì„±ì„ 위한 코드로 권장ë¨) ì‚¬ìš©í• ìˆ˜ 있다. ë§Œì¼ ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ EJB 컨테ì´ë„ˆì—ì„œ ì‹¤í–‰í•˜ê³ ìžˆì„ ê²½ìš°, CMTì˜ ê²½ìš°ì— ì„ ì–¸ì ì¸ íŠ¸ëžœìžì…˜ ê²½ê³„ì„¤ì •ì´ ì„ í˜¸ëœë‹¤."
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr "JMX 배치"
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr "<literal>cfg.buildSessionFactory()</literal> ì¤„ì€ ì—¬ì „ížˆ JNDIì— ë¶™ì€ í•˜ë‚˜ì˜ <literal>SessionFactory</literal>를 얻기 위해 어딘가ì—ì„œ 실행ë˜ì–´ì•¼ 한다. ë‹¹ì‹ ì€ (<literal>HibernateUtil</literal> ë‚´ì— ìžˆëŠ” 것처럼) <literal>static</literal> initializer ë¸”ë¡ ì†ì—ì„œ ì´ê²ƒì„ í–‰í• ìˆ˜ 있거나 ë‹¹ì‹ ì€ Hibernate를 <emphasis>managed service</emphasis>로서 ë°°ì¹˜í• ìˆ˜ 있다."
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr "Hibernate는 JBoss AS와 ê°™ì€ JMX ê°€ìš©ì„±ë“¤ì„ ê°€ì§„ 어플리케ì´ì…˜ 서버 ìƒì˜ 배치를 위해 <literal>org.hibernate.jmx.HibernateService</literal>를 ë°°í¬í•˜ê³ 있다. ì‹¤ì œ 배치와 êµ¬ì„±ì€ ë²¤ë” ì§€ì •ì ì´ë‹¤. 다ìŒì€ JBoss 4.0.x를 위한 <literal>jboss-service.xml</literal> ì˜ˆì œì´ë‹¤:"
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr "ì´ íŒŒì¼ì€ <literal>META-INF</literal>ë¡œ ëª…ëª…ëœ ë””ë ‰í† ë¦¬ ì†ì— 배치ë˜ê³ í™•ìž¥ìž <literal>.sar</literal> (service archive)를 가진 í•œ ê°œì˜ JAR íŒŒì¼ ì†ì— 패키징ëœë‹¤. ë‹¹ì‹ ì€ ë˜í•œ Hibernate, ê·¸ê²ƒì˜ í•„ìš”í•œ ì œ 3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤, ë‹¹ì‹ ì˜ ì»´íŒŒì¼ëœ ì˜ì† í´ëž˜ìŠ¤ë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ ë‹¹ì‹ ì˜ ë§¤í•‘ 파ì¼ë“¤ì„ ë™ì¼í•œ ì•„ì¹´ì´ë¸Œ ì†ì— íŒ¨í‚¤ì§•í• í•„ìš”ê°€ 있다. ë‹¹ì‹ ì˜ ì—”í„°í”„ë¼ì´ì¦ˆ 빈즈(대개 session beans)는 그것들 ìžì‹ ì˜ JAR íŒŒì¼ ì†ì— ìœ ì§€ë 수 있지만, ë‹¹ì‹ ì€ í•œ ê°œì˜ (hot-)배치 가능한 단위를 얻기 위해 ë©”ì¸ ì„œë¹„ìŠ¤ ì•„ì¹´ì´ë¸Œ ì†ì— ì´ EJB JAR 파ì¼ì„ í¬í•¨ì‹œí‚¬ ìˆ˜ë„ ìžˆë‹¤. JMX 서비스와 EJB ë°°ì¹˜ì— ê´€í•œ 추가 ì •ë³´ëŠ” JBoss AS 문서를 참조하ë¼."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,362 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr "ì¸í„°ì…‰í„°ë“¤ê³¼ ì´ë²¤íŠ¸ë“¤"
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr "어플리케ì´ì…˜ì´ Hibernate 내부ì—ì„œ ë°œìƒí•˜ëŠ” ì–´ë–¤ ì´ë²¤íŠ¸ë“¤ì— 대해 ë°˜ì‘하는 ê²ƒì— í”히 ìœ ìš©í•˜ë‹¤. ì´ê²ƒì€ ì–´ë–¤ ì¢…ë¥˜ì˜ ì¼ë°˜ì ì¸ ê¸°ëŠ¥, ê·¸ë¦¬ê³ Hibernateì˜ í™•ìž¥ ê¸°ëŠ¥ì˜ êµ¬í˜„ì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr "ì¸í„°ì…‰í„°ë“¤"
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr "<literal>Interceptor</literal> ì¸í„°íŽ˜ì´ìŠ¤ëŠ” ì˜ì† ê°ì²´ê°€ ì €ìž¥ë˜ê³ , ì—…ë°ì´íŠ¸ë˜ê³ , ì‚ì œë˜ê±°ë‚˜ 로드ë˜ê¸° ì „ì— ì˜ì† ê°ì²´ì˜ 프로í¼í‹°ë“¤ì„ ì¡°ì‚¬í•˜ê³ /하거나 처리하는 ê²ƒì„ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— í—ˆìš©í•´ì¤Œìœ¼ë¡œì¨ ì„¸ì…˜ìœ¼ë¡œë¶€í„° 어플리케ì´ì…˜ìœ¼ë¡œì˜ ì½œë°±ë“¤ì„ ì œê³µí•œë‹¤. ì´ê²ƒì— 대한 í•œ 가지 가능한 ì‚¬ìš©ì€ ê°ì‚¬ ì •ë³´ë¥¼ 추ì 하는 것ì´ë‹¤. 예를 들어, ë‹¤ìŒ <literal>Interceptor</literal>는 <literal>Auditable</literal>ì´ ìƒì„±ë ë•Œ <literal>createTimestamp</literal>를 ìžë™ì 으로 ì„¤ì •í•˜ê³ <literal>Auditable</literal>ì´ ì—…ë°ì´íŠ¸ë ë•Œ <literal>lastUpdateTimestamp</literal> 프로í¼í‹°ë¥¼ ì—…ë°ì´íŠ¸ 한다."
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr "ë‹¹ì‹ ì€ <literal>Interceptor</literal>를 ì§ì ‘ 구현해야 하거나 (ë” ì¢‹ê²ŒëŠ”) <literal>EmptyInterceptor</literal>를 확장(extend)해야 한다."
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr "ì¸í„°ì…‰í„°ë“¤ì€ ë‹¤ìŒ ë‘ ê°œì˜ íŠ¹ì§•ë“¤ë¡œ 나타난다: <literal>Session</literal>-ì˜ì—í™” ê·¸ë¦¬ê³ <literal>SessionFactory</literal>-ì˜ì—í™”."
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr "<literal>Session</literal>-ì˜ì—ì˜ ì¸í„°ì…‰í„°ëŠ” ì„¸ì…˜ì´ í•˜ë‚˜ì˜ <literal>Interceptor</literal>를 수용하는 ì˜¤ë²„ë¡œë“œëœ SessionFactory.openSession() 메소드들 중 하나를 사용하여 열릴 ë•Œ ì§€ì •ëœë‹¤."
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ <literal>Configuration</literal>ì„ ì‚¬ìš©í•˜ì—¬ ì¸í„°ì…‰í„°ë¥¼ ì „ì— ë ˆë²¨ ìƒì— ì„¤ì •í• ìˆ˜ë„ ìžˆë‹¤. ì´ ê²½ìš°ì—, ì¸í„°ì…‰í„°ëŠ” threadsafeì´ì–´ì•¼ 한다."
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+
+#: index.docbook:61
+msgid "Event system"
+msgstr "<literal>SessionFactory</literal>-ì˜ì—ì˜ ì¸í„°ì…‰í„°ëŠ” <literal>SessionFactory</literal>ì„ ë¹Œë“œí•˜ê¸°ì— ì•žì„œ <literal>Configuration</literal> ê°ì²´ì— 등ë¡ëœë‹¤. ì´ ê²½ìš°ì—, 공급ë˜ëŠ” ì¸í„°ì…‰í„°ëŠ” ê·¸ <literal>SessionFactory</literal>로부터 ì—´ë ¤ì§„ ëª¨ë“ ì„¸ì…˜ë“¤ì— ì ìš©ë 것ì´ë‹¤; í•˜ë‚˜ì˜ ì„¸ì…˜ì´ ì‚¬ìš©í• ì¸í„°ì…‰í„°ë¥¼ 명시ì 으로 ì§€ì •í•˜ì—¬ 열리지 않는 í•œ ì´ê²ƒì€ ì°¸ì´ë‹¤. <literal>SessionFactory</literal>-ì˜ì—ì˜ ì¸í„°ì…‰í„°ë“¤ì€ 세션-ì§€ì •ì ì¸ ìƒíƒœë¥¼ ì €ìž¥í•˜ì§€ ì•Šë„ë¡ ì£¼ì˜í•˜ì—¬ ì“°ë ˆë“œ-ì•ˆì „í•´ì•¼ 한다. 왜ëƒí•˜ë©´ 다중 ì„¸ì…˜ë“¤ì€ (ìž ì •ì 으로) ì´ ì¸í„°ì…‰í„°ë¥¼ ë™ì‹œì 으로 ì‚¬ìš©í• ê²ƒì´ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr "ì´ë²¤íŠ¸ 시스템"
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ì˜ì† 계층ì—ì„œ íŠ¹ì • ì´ë²¤íŠ¸ë“¤ì— 대해 ë°˜ì‘해야 한다면, ë‹¹ì‹ ì€ ë˜í•œ Hibernate3 <emphasis>event</emphasis> 아키í…처를 ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤. ì´ë²¤íŠ¸ ì‹œìŠ¤í…œì€ ë¶€ê°€ë¬¼ë¡œ 사용ë 수 있거나 ì¸í„°ì…‰í„°ë“¤ì— 대한 대체물로 사용ë 수 있다."
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr "본질ì 으로 <literal>Session</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ ëª¨ë“ ë©”ì†Œë“œë“¤ì€ ì´ë²¤íŠ¸ì™€ 서로 ê´€ë ¨ë˜ì–´ 있다. ë‹¹ì‹ ì€ <literal>LoadEvent</literal>, <literal>FlushEvent</literal>, ë“±ì„ ê°–ëŠ”ë‹¤ (ì •ì˜ëœ ì´ë²¤íŠ¸ íƒ€ìž…ë“¤ì˜ ì „ì²´ ë¦¬ìŠ¤íŠ¸ì— ëŒ€í•´ì„œëŠ” XML 구성 íŒŒì¼ DTD ë˜ëŠ” <literal>org.hibernate.event</literal> 패키지를 참조하ë¼). í•˜ë‚˜ì˜ ìš”ì²ì´ ì´ë“¤ 메소드들 중 í•˜ë‚˜ì— ì˜í•´ 만들어질 ë•Œ, Hibernate <literal>Session</literal>ì€ ì ì ˆí•œ ì´ë²¤íŠ¸ë¥¼ ìƒì„±ì‹œí‚¤ê³ ê·¸ê²ƒì„ ê·¸ íƒ€ìž…ì˜ êµ¬ì„±ëœ ì´ë²¤íŠ¸ 리스너ì—게 ì „ë‹¬í•œë‹¤. 박싱없ì´, ì´ë“¤ ë¦¬ìŠ¤ë„ˆë“¤ì€ ê·¸ë“¤ ë©”ì†Œë“œë“¤ì´ í•ìƒ 귀결ë˜ì—ˆë˜ ë™ì¼í•œ í”„ë¡œì„¸ì‹±ì„ êµ¬í˜„í•œë‹¤. 하지만 ë‹¹ì‹ ì´ ë¦¬ìŠ¤ë„ˆ ì¸í„°íŽ˜ì´ìŠ¤ë“¤ 중 í•˜ë‚˜ì˜ ë§žì¶¤ì„ êµ¬í˜„í•˜ëŠ” ê²ƒì´ ìžìœ ë¡ê³ (예를 들어 <literal>LoadEvent</literal>는 <literal>LoadEventListener</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ 등ë¡ëœ êµ¬í˜„ì— ì˜í•´ 처리ëœë‹¤)!
, ê·¸ ê²½ìš°ì— ê·¸ë“¤ êµ¬í˜„ì€ <literal>Session</literal>ì— ëŒ€í•´ 행해진 ìž„ì˜ì˜ <literal>load()</literal> ìš”ì²ë“¤ì„ ì²˜ë¦¬í• ì±…ìž„ì´ ìžˆì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr "ë¦¬ìŠ¤ë„ˆë“¤ì€ íš¨ìœ¨ì ì´ê²Œë” 싱글톤(singleton)들로 간주ë˜ì–´ì•¼ í• ê²ƒì´ë‹¤; ì´ê²ƒì€ ê·¸ê²ƒë“¤ì´ ìš”ì²ë“¤ 사ì´ì—ì„œ ê³µìœ ë˜ê³ , ë”°ë¼ì„œ ìž„ì˜ì˜ ìƒíƒœë¥¼ ì¸ìŠ¤í„´ìŠ¤ 변수들로서 ì €ìž¥í•˜ì§€ ë§ì•„야 í•¨ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr "맞춤형 리스너는 ê·¸ê²ƒì´ íŽ¸ì˜ì ì¸ ê¸°ì € í´ëž˜ìŠ¤ë“¤(ë˜ëŠ” ë¦¬ìŠ¤ë„ˆë“¤ì´ ì´ ìš©ë„ë¡œ finalì´ ì•„ë‹Œ 것으로 ì„ ì–¸ë˜ë¯€ë¡œ Hibernate out-of-the-boxì— ì˜í•´ ì‚¬ìš©ëœ ë””í´íŠ¸ ì´ë²¤íŠ¸ 리스너들) 중 하나를 ì²˜ë¦¬í•˜ê³ /하거나 í™•ìž¥í•˜ê³ ìž ì›í•˜ëŠ” ì´ë²¤íŠ¸ë“¤ì— 대해 ì ì ˆí•œ ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현해야 한다. 맞춤형 ë¦¬ìŠ¤ë„ˆë“¤ì€ <literal>Configuration</literal> ê°ì²´ë¥¼ 통해 프로그램 ìƒìœ¼ë¡œ 등ë¡ë 수 있거나, Hibernate 구성 XML ì†ì— ì§€ì •ë 수 있다 (properties 파ì¼ì„ 통한 ì„ ì–¸ì ì¸ êµ¬ì„±ì€ ì§€ì›ë˜ì§€ 않는다). 다ìŒì€ 맞춤형 load ì´ë²¤íŠ¸ ë¦¬ìŠ¤ë„ˆì— ëŒ€í•œ ì˜ˆì œì´ë‹¤:"
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ë””í´íŠ¸ ë¦¬ìŠ¤ë„ˆì— ë§ë¶™ì—¬ ê·¸ 리스너를 사용하ë„ë¡ Hibernateì—게 ì•Œë ¤ì£¼ëŠ” 구성 엔트리를 필요로 한다:"
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr "ëŒ€ì‹ ì— ë‹¹ì‹ ì€ ê·¸ê²ƒì„ í”„ë¡œê·¸ëž˜ë° ë°©ì‹ìœ¼ë¡œ 등ë¡í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr "ì„ ì–¸ì 으로 등ë¡ëœ ë¦¬ìŠ¤ë„ˆë“¤ì€ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ê³µìœ í• ìˆ˜ 없다. ë§Œì¼ ë™ì¼í•œ í´ëž˜ìŠ¤ ì´ë¦„ì´ ì—¬ëŸ¬ ê°œì˜ <literal><listener/></literal> 요소들ì—ì„œ 사용ë 경우, ê°ê°ì˜ 참조는 ê·¸ í´ëž˜ìŠ¤ì— 대한 별ë„ì˜ ì¸ìŠ¤í„´ìŠ¤ë¡œ 귀결ë 것ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ë¦¬ìŠ¤ë„ˆ 타입들 사ì´ì—ì„œ 리스너 ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ê³µìœ í• ê°€ìš©ì„±ì„ í•„ìš”ë¡œ í• ê²½ìš° ë‹¹ì‹ ì€ í”„ë¡œê·¸ëž˜ë° ë°©ì‹ì˜ ë“±ë¡ ì ‘ê·¼ë²•ì„ ì‚¬ìš©í•´ì•¼ 한다."
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr "구성 ë™ì•ˆì— 왜 ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ êµ¬í˜„í•˜ê³ íŠ¹ì • íƒ€ìž…ì„ ì§€ì •í•˜ëŠ”ê°€? ë¬¼ë¡ ë¦¬ìŠ¤ë„ˆ êµ¬í˜„ì€ ì—¬ëŸ¬ ê°œì˜ ì´ë²¤íŠ¸ 리스너 ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì„ êµ¬í˜„í• ìˆ˜ 있다. ë“±ë¡ ë™ì•ˆì— 추가ì 으로 íƒ€ìž…ì„ ì •ì˜í•˜ëŠ” ê²ƒì€ ì»¨í”¼ê·¸ë ˆì´ì…˜ ë™ì•ˆì— 맞춤형 ë¦¬ìŠ¤ë„ˆë“¤ì˜ ì‚¬ìš© 여부를 ì „í™˜ì‹œí‚¤ëŠ” ê²ƒì„ ë” ì‰½ê²Œ 해준다."
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr "Hibernate ì„ ì–¸ì ì¸ ë³´ì•ˆ"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr "대개 Hibernate 어플리케ì´ì…˜ë“¤ì—ì„œ ì„ ì–¸ì ì¸ ë³´ì•ˆì€ session facade 계층 ë‚´ì—ì„œ 관리ëœë‹¤. ì´ì œ, Hibernate3는 ì–´ë–¤ ì•¡ì…˜ë“¤ì´ JACC를 통해 í¼ë¯¸ì…˜ì„ ì£¼ì–´ì§€ê³ , JAAS를 통해 ì¸ê°€ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤. ì´ê²ƒì€ ëª¨ë“ ì•„í‚¤í…ì²˜ì˜ ìƒë‹¨ì— ë¹Œë“œëœ ì˜µì…˜ 기능ì´ë‹¤."
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr "ë¨¼ì €, ë‹¹ì‹ ì€ JAAS authorization ì‚¬ìš©ì„ ì´ìš© 가능하ë„ë¡ í•˜ê¸° 위해 ì ì ˆí•œ ì´ë²¤íŠ¸ ë¦¬ìŠ¤í„°ë“¤ì„ êµ¬ì„±í•´ì•¼ 한다."
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr "<literal><listener type=\"...\" class=\"...\"/></literal>는 íŠ¹ì • ì´ë²¤íŠ¸ íƒ€ìž…ì— ëŒ€í•´ ì •í™•ížˆ í•œ ê°œì˜ ë¦¬ìŠ¤ë„ˆê°€ ì¡´ìž¬í• ë•Œ 단지 <literal><event type=\"...\"><listener class=\"...\"/></event></literal>ì˜ ë‹¨ì¶•í˜•ìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr "다ìŒìœ¼ë¡œ, ì—¬ì „ížˆ <literal>hibernate.cfg.xml</literal> ë‚´ì—ì„œ í¼ë¯¸ì…˜ë“¤ì„ roleë“¤ì— ë°”ì¸ë“œ 시킨다 :"
+
+#: index.docbook:146
+msgid "appended paragraph 1"
+msgstr ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+
+#: index.docbook:148
+msgid "appended paragraph 2"
+msgstr "ì—í• (role) ì´ë¦„ë“¤ì€ ë‹¹ì‹ ì˜ JACC 프로바ì´ë”ì— ì˜í•´ ì¸ì§€ëœ ì—í• (role)들ì´ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1162 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr "ì˜ˆì œ: 여러 가지 매핑들"
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr "ì´ ìž¥ì€ ëª‡ëª‡ 보다 복잡한 ì—°ê´€ ë§¤í•‘ë“¤ì„ ë³´ì—¬ì¤€ë‹¤."
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr "Employer/Employee"
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr "<literal>Employer</literal>와 <literal>Employee</literal> 사ì´ì˜ ê´€ê³„ì— ëŒ€í•œ ë‹¤ìŒ ëª¨í˜•ì€ ê·¸ 연관를 표현하는 ë° ì‹¤ì œ 엔티티 í´ëž˜ìŠ¤(<literal>Employment</literal>)를 사용한다. ë™ì¼í•œ ë‘ ë¶€ë¶„ë“¤ì— ëŒ€í•´ 하나 ì´ìƒì˜ 채용 주기가 ì¡´ìž¬í• ìˆ˜ 있기 ë•Œë¬¸ì— ì´ê²ƒì´ 행해진다. ì»´í¬ë„ŒíŠ¸ë“¤ì´ í™”í 값들과 ì¢…ì—…ì› ì´ë¦„ë“¤ì„ ëª¨í˜•í™” ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr "다ìŒì€ 가능한 매핑 문서ì´ë‹¤:"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr "ê·¸ë¦¬ê³ ë‹¤ìŒì€ <literal>SchemaExport</literal>ì— ì˜í•´ ìƒì„±ëœ í…Œì´ë¸” 스키마ì´ë‹¤."
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr "Author/Work"
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr "<literal>Work</literal>, <literal>Author</literal> ê·¸ë¦¬ê³ <literal>Person</literal> 사ì´ì˜ ê´€ê³„ë“¤ì— ëŒ€í•œ ë‹¤ìŒ ëª¨í˜•ì„ ê²€í† í•˜ìž. 우리는 <literal>Work</literal>ê³¼ <literal>Author</literal> 사ì´ì˜ 관계를 many-to-many 연관으로 표현한다. 우리는 <literal>Author</literal>와 <literal>Person</literal> 사ì´ì˜ 관계를 one-to-one 연관으로 í‘œí˜„í•˜ê³ ìž ì„ íƒí•œë‹¤. ë˜ ë‹¤ë¥¸ ê°€ëŠ¥ì„±ì€ <literal>Author</literal>ê°€ <literal>Person</literal>ì„ í™•ìž¥í•˜ë„ë¡ í•˜ëŠ” ê²ƒì¼ ê²ƒì´ë‹¤."
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr "ë‹¤ìŒ ë§¤í•‘ 문서는 ì´ë“¤ ê´€ê³„ë“¤ì„ ì •í™•í•˜ê²Œ 표현한다:"
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr "ì´ ë§¤í•‘ì—는 네 ê°œì˜ í…Œì´ë¸”ë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal>works</literal>, <literal>authors</literal>와 <literal>persons</literal>ì€ ê°ê° ìž‘ì—… ë°ì´í„°, ì €ìž ë°ì´í„°, ê°œì¸ ë°ì´í„°ë¥¼ 보관한다. <literal>author_work</literal>는 ì €ìžë“¤ì„ ìž‘ì—…ë“¤ì— ì—°ê²°ì‹œí‚¤ëŠ” ì—°ê´€ í…Œì´ë¸”ì´ë‹¤. 다ìŒì€ <literal>SchemaExport</literal>ì— ì˜í•´ ìƒì„±ëœ í…Œì´ë¸” 스키마ì´ë‹¤."
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr "Customer/Order/Product"
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr "ì´ì œ <literal>Customer</literal>, <literal>Order</literal>와 <literal>LineItem</literal> ê·¸ë¦¬ê³ <literal>Product</literal> 사ì´ì˜ ê´€ê³„ë“¤ì— ê´€í•œ ëª¨í˜•ì„ ê²€í† í•˜ìž. <literal>Customer</literal>와 <literal>Order</literal> 사ì´ì˜ one-to-many ì—°ê´€ì´ ì¡´ìž¬í•˜ì§€ë§Œ, 우리는 어떻게 <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>를 í‘œí˜„í• ê²ƒì¸ê°€? 나는 <literal>Order</literal>와 <literal>Product</literal> 사ì´ì˜ many-to-many 연관를 나타내는 í•˜ë‚˜ì˜ ì—°ê´€ í´ëž˜ìŠ¤ë¡œì„œ <literal>LineItem</literal>ì„ ë§¤í•‘í•˜ê¸°ë¡œ ì„ íƒí–ˆë‹¤. Hibernateì—ì„œ ì´ê²ƒì€ composite 요소로 명명ëœë‹¤."
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr "매핑 문서:"
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> ê·¸ë¦¬ê³ <literal>products</literal>는 ê°ê° ê³ ê° ë°ì´í„°, 주문 ë°ì´í„°, 주문 ë¼ì¸ ì•„ì´í…œ ë°ì´í„°, ê·¸ë¦¬ê³ ì œí’ˆ ë°ì´í„°ë¥¼ 보관한다. <literal>line_items</literal>는 ë˜í•œ ì£¼ë¬¸ë“¤ì„ ì œí’ˆë“¤ê³¼ 연결시키는 ì—°ê´€ í…Œì´ë¸”로서 ë™ìž‘한다."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr "기타 ì˜ˆì œ 매핑들"
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr "ì´ë“¤ ì˜ˆì œë“¤ì€ ëª¨ë‘ Hiberante test suite로부터 취했다. ë‹¹ì‹ ì€ ê±°ê¸°ì„œ ë§Žì€ ë‹¤ë¥¸ ìœ ìš©í•œ ì˜ˆì œ ë§¤í•‘ë“¤ì„ ë°œê²¬í• ê²ƒì´ë‹¤. Hibernate ë°°í¬ë³¸ì˜ <literal>test</literal> í´ë”를 살펴보ë¼."
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr "TODO: ì´ ë‚´ìš©ì„ ë‘˜ëŸ¬ì‹¼ ë§ë“¤ì„ ì§‘ì–´ë„£ì„ ê²ƒ."
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr "\"형ì‹í™”ëœ(Typed)\" one-to-one ì—°ê´€"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr "Composite 키 ì˜ˆì œ"
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr "ê³µìœ ëœ í•©ì„± 키 ì†ì„±ì„ 가진 Many-to-many"
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr "ë‚´ìš© 기반 íŒë³„"
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr "대체 í‚¤ë“¤ì— ëŒ€í•œ 연관들"
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,350 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr "ì˜ˆì œ: 부모/ìžì‹"
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr "새로운 사용ìžë“¤ì´ Hibernateë¡œ í–‰í•˜ê³ ìž ì‹œë„하는 바로 첫 번째 것들 중 하나는 부모/ìžì‹ íƒ€ìž…ì˜ ê´€ê³„ë¥¼ 모형화 시키는 것ì´ë‹¤. ì´ê²ƒì— 대한 ë‘ ê°€ì§€ 다른 ì ‘ê·¼ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤. 여러가지 ì´ìœ 들로 ì¸í•´ 특히 새로운 사용ìžë“¤ì—게 가장 편한 ì ‘ê·¼ë²•ì€ <literal>Parent</literal>로부터 <literal>Child</literal>ë¡œì˜ <literal><one-to-many></literal> ì—°ê´€ì„ ê°€ì§„ 엔티티 í´ëž˜ìŠ¤ë“¤ë¡œì„œ <literal>Parent</literal>와 <literal>Child</literal> ì–‘ìžë¥¼ 모형화 시키는 것ì´ë‹¤. (다른 ì ‘ê·¼ë²•ì€ <literal>Child</literal>를 <literal><composite-element></literal>ë¡œ ì„ ì–¸í•˜ëŠ” 것ì´ë‹¤.) ì´ì œ, (Hibernateì—ì„œ) one to many ì—°ê´€ì— ëŒ€í•œ ë””í´íŠ¸ ì˜ë¯¸ëŠ” composite 요소 ë§¤í•‘ì˜ ì˜ë¯¸ë³´ë‹¤ 부모/ìžì‹ ê´€ê³„ì˜ í†µìƒì ì¸ ì˜ë¯¸ì— 훨씬 ëœ ê°€ê¹ë‹¤ëŠ” ê²ƒì´ íŒëª…ëœë‹¤. 우리는 부모/ìžì‹ 관계를 효율ì ì´ê³ ê°•ë ¥í•˜ê²Œ 모형화 ì‹!
œí‚¤ê¸° 위해 <emphasis>케스케ì´ë“œë“¤ì„ 가진 ì–‘ë°©í–¥ one to many ì—°ê´€</emphasis>ì„ ì‚¬ìš©í•˜ëŠ” ë°©ë²•ì„ ì„¤ëª…í• ê²ƒì´ë‹¤. ê·¸ê²ƒì€ ì „í˜€ ì–´ë µì§€ 않다!"
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr "ì½œë ‰ì…˜ë“¤ì— ê´€í•œ 노트"
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr "Hibernate ì½œë ‰ì…˜ë“¤ì€ ê·¸ê²ƒë“¤ì˜ ì†Œìœ í•˜ê³ ìžˆëŠ” ì—”í‹°í‹°ì˜ ë…¼ë¦¬ì 부분으로 간주ëœë‹¤; ê²°ì½” í¬í•¨ëœ ì—”í‹°í‹°ë“¤ì˜ ë¶€ë¶„ì´ ì•„ë‹ˆë‹¤. ì´ê²ƒì€ 중대한 구분ì ì´ë‹¤! ê·¸ê²ƒì€ ë‹¤ìŒì€ ë‹¤ìŒ ê²°ê³¼ë“¤ì„ ê°–ëŠ”ë‹¤:"
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr "ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° ê°ì²´ë¥¼ ì œê±°í•˜ê³ /ì½œë ‰ì…˜ì— ê°ì²´ë¥¼ 추가 시킬 ë•Œ, ì½œë ‰ì…˜ ì†Œìœ ìžì˜ ë²„ì „ 번호가 ì¦ê°€ëœë‹¤."
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr "ë§Œì¼ ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° ì œê±°ë˜ì—ˆë˜ ê°ì²´ê°€ í•˜ë‚˜ì˜ ê°’ íƒ€ìž…ì˜ ì¸ìŠ¤í„´ìŠ¤(예를 들어 composite 요소)ì´ë©´, ê·¸ ê°ì²´ëŠ” ì˜ì†ìƒíƒœë¥¼ ëë‚´ê³ ê·¸ê²ƒì˜ ìƒíƒœê°€ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ì™„ì „ížˆ ì œê±°ë 것ì´ë‹¤. 마찬가지로 í•˜ë‚˜ì˜ ê°’ íƒ€ìž…ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì½œë ‰ì…˜ì— ì¶”ê°€ì‹œí‚¤ëŠ” ê²ƒì€ ê·¸ê²ƒì˜ ìƒíƒœê°€ 즉시 ì˜ì†í™” ë˜ë„ë¡ ê°•ì œì‹œí‚¬ 것ì´ë‹¤."
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr "반면ì—, ë§Œì¼ ì—”í‹°í‹°ê°€ ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° ì œê±°ë 경우(one-to-many ë˜ëŠ” many-to-many ì—°ê´€), ê·¸ê²ƒì€ ë””í´íŠ¸ë¡œ ì‚ì œë˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. ì´ íŠ¹ì§•ì€ ì™„ì „í•˜ê²Œ ì¼ê´€ì ì´ë‹¤ - 다른 ì—”í‹°í‹°ì˜ ë‚´ë¶€ ìƒíƒœì— 대한 ë³€ê²½ì€ ì—°ê´€ëœ ì—”í‹°í‹°ë¥¼ 사ë¼ì§€ë„ë¡ ê°•ì œí•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤! 마찬가지로 ì½œë ‰ì…˜ì— ì—”í‹°í‹°ë¥¼ 추가시키는 ê²ƒì€ ë””í´íŠ¸ë¡œ ê·¸ 엔티티가 ì˜ì†í™” ë˜ë„ë¡ ê°•ì œì‹œí‚¤ì§€ 않는다."
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr "ëŒ€ì‹ ì— ì½œë ‰ì…˜ìœ¼ë¡œì˜ ì—”í‹°í‹° 추가가 ë‘ ì—”í‹°í‹°ë“¤ 사ì´ì— 단지 í•˜ë‚˜ì˜ ë§í¬ë¥¼ ìƒì„±ì‹œí‚¤ëŠ” 반면ì—, ê·¸ê²ƒì„ ì œê±°í•˜ëŠ” ê²ƒì€ ë§í¬ë¥¼ ì œê±°í•œë‹¤ëŠ” ì ì´ ë””í´íŠ¸ 특징ì´ë‹¤. ì´ê²ƒì€ ëª¨ë“ ì¢…ë¥˜ì˜ ê²½ìš°ë“¤ì— ëŒ€í•´ 매우 ì ì ˆí•˜ë‹¤. ê·¸ê²ƒì´ ì „í˜€ ì ì ˆí•˜ì§€ ì•Šì€ ê³³ì€ ë¶€ëª¨/ìžì‹ ê´€ê³„ì¸ ê²½ìš°ì´ê³ , 여기서 ìžì‹ì˜ ìƒì• 는 ë¶€ëª¨ì˜ ìƒëª…ì£¼ê¸°ì— ë¬¶ì—¬ì ¸ 있다."
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr "ì–‘ë°©í–¥ one-to-many"
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr "<literal>Parent</literal>로부터 <literal>Child</literal>ë¡œì˜ ê°„ë‹¨í•œ <literal><one-to-many></literal> 연관관계로 ì‹œìž‘í•œë‹¤ê³ ê°€ì •í•˜ìž."
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr "우리가 ë‹¤ìŒ ì½”ë“œë¥¼ 실행시켰다면"
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr "Hibernate는 ë‘ ê°œì˜ SQL ë¬¸ìž¥ë“¤ì„ ì‹¤í–‰í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr "<literal>c</literal>ì— ëŒ€í•œ ë ˆì½”ë“œë¥¼ ìƒì„±ì‹œí‚¤ëŠ” <literal>INSERT</literal>"
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr "<literal>p</literal>로부터 <literal>c</literal>ë¡œì˜ ë§í¬ë¥¼ ìƒì„±ì‹œí‚¤ëŠ” <literal>UPDATE</literal>"
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr "ì´ê²ƒì€ 비효율ì ì¼ ë¿ë§Œ 아니ë¼, ë˜í•œ <literal>parent_id</literal> 컬럼 ìƒì˜ ìž„ì˜ì˜ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì— 위배ëœë‹¤. 우리는 ì½œë ‰ì…˜ 매핑ì—ì„œ <literal>not-null=\"true\"</literal>를 ì§€ì •í•¨ìœ¼ë¡œì¨ null 허용 가능 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ ìœ„ë°˜ì„ ì •ì •í• ìˆ˜ 있다:"
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr "하지만 ì´ê²ƒì€ 권장ë˜ëŠ” í•´ê²°ì±…ì´ ì•„ë‹ˆë‹¤."
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr "ì´ í–‰ìœ„ì˜ ê¸°ë³¸ ì›ì¸ì€ <literal>p</literal>로부터 <literal>c</literal>ë¡œì˜ ë§í¬(foreign key <literal>parent_id</literal>)ê°€ <literal>Child</literal> ê°ì²´ì˜ ìƒíƒœì˜ 부분으로 간주ë˜ì§€ ì•Šê³ ê·¸ëŸ¬ë¯€ë¡œ <literal>INSERT</literal>ë¡œ ìƒì„±ë˜ì§€ 않는다는 ì ì´ë‹¤. ë”°ë¼ì„œ í•´ê²°ì±…ì€ <literal>Child</literal> ë§¤í•‘ì˜ ë§í¬ ë¶€ë¶„ì„ ë§Œë“œëŠ” 것ì´ë‹¤."
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr "(우리는 ë˜í•œ <literal>parent</literal> 프로í¼í‹°ë¥¼ <literal>Child</literal> í´ëž˜ìŠ¤ì— 추가시킬 필요가 있다.)"
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr "ì´ì œ <literal>Child</literal> 엔티티가 ë§í¬ì˜ ìƒíƒœë¥¼ 관리한다는 ì ì„ ë…¸íŠ¸í•˜ê³ , 우리는 ë§í¬ë¥¼ ì—…ë°ì´íŠ¸ 시키지 ë§ë„ë¡ ì½œë ‰ì…˜ì—게 통보한다. 우리는 <literal>inverse</literal> ì†ì„±ì„ 사용한다."
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr "ë‹¤ìŒ ì½”ë“œëŠ” 새로운 <literal>Child</literal>를 ì¶”ê°€ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë 것ì´ë‹¤"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr "ê·¸ë¦¬ê³ ì´ì œ, ìœ ì¼í•˜ê²Œ í•œ ê°œì˜ SQL <literal>INSERT</literal>ê°€ 실행ë 것ì´ë‹¤!"
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr "약간 ê±°ì¹ ê²Œ, 우리는 <literal>Parent</literal>ì˜ <literal>addChild()</literal> 메소드를 ìƒì„±ì‹œí‚¬ 수 있다."
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr "ì´ì œ, <literal>Child</literal>를 추가하는 코드는 다ìŒê³¼ 같다"
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr "케스케ì´ë”© ìƒëª…주기"
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr "<literal>save()</literal>ì— ëŒ€í•œ 명시ì ì¸ í˜¸ì¶œì€ ì—¬ì „ížˆ 성가시다. 우리는 케스케ì´ë”©ì„ 사용하여 ì´ê²ƒì„ ì–˜ê¸°í• ê²ƒì´ë‹¤."
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr "다ìŒì€ ìœ„ì˜ ì½”ë“œë¥¼ 단순화 시킨다"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr "ìœ ì‚¬í•˜ê²Œ, 우리는 <literal>Parent</literal>를 ì €ìž¥í•˜ê±°ë‚˜ ì‚ì œí• ë•Œ ìžì‹ë“¤ì— 대해 반복하는 ê²ƒì„ í•„ìš”ë¡œ 하지 않는다. 다ìŒì€ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° <literal>p</literal>와 ëª¨ë“ ê·¸ê²ƒì˜ ìžì‹ë“¤ì„ ì œê±°ì‹œí‚¨ë‹¤."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr "하지만, ë‹¤ìŒ ì½”ë“œ"
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr "는 ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° <literal>c</literal>를 ì œê±°í•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤; ê·¸ê²ƒì€ ì˜¤ì§ <literal>p</literal>ì— ëŒ€í•œ ë§í¬ë§Œì„ ì œê±°í• ê²ƒì´ë‹¤(ê·¸ë¦¬ê³ ì´ ê²½ìš°ì— <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ ìœ„ë°˜ì„ ì¼ìœ¼í‚¬ 것ì´ë‹¤ ). ë‹¹ì‹ ì€ ëª…ì‹œì 으로 <literal>Child</literal>를 <literal>delete()</literal> 시킬 필요가 있다."
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr "ì´ì œ ìš°ë¦¬ì˜ ê²½ìš°ì— <literal>Child</literal>는 ê·¸ê²ƒì˜ ë¶€ëª¨ ì—†ì´ëŠ” ì§„ì •ìœ¼ë¡œ ì¡´ìž¬í• ìˆ˜ 없다. ë”°ë¼ì„œ ë§Œì¼ ìš°ë¦¬ê°€ ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° í•˜ë‚˜ì˜ <literal>Child</literal>를 ì œê±°í• ê²½ìš°, 우리는 ê·¸ê²ƒì´ ì •ë§ë¡œ ì‚ì œë˜ê¸°ë¥¼ ì›í•œë‹¤. ì´ë¥¼ 위해 우리는 <literal>cascade=\"all-delete-orphan\"</literal>ì„ ì‚¬ìš©í•´ì•¼ 한다."
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr "노트: ë¹„ë¡ ì½œë ‰ì…˜ ë§¤í•‘ì´ <literal>inverse=\"true\"</literal>를 ì§€ì •í• ì§€ë¼ë„, 케스케ì´ë“œë“¤ì€ ì—¬ì „ížˆ ì½œë ‰ì…˜ ìš”ì†Œë“¤ì„ ë°˜ë³µí•¨ìœ¼ë¡œì¨ ì²˜ë¦¬ëœë‹¤. ë”°ë¼ì„œ ê°ì²´ê°€ 케스케ì´ë“œì— ì˜í•´ ì €ìž¥ë˜ê³ , ì‚ì œë˜ê±°ë‚˜ ì—…ë°ì´íŠ¸ ë˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì´ í•„ìš”ë¡œ í• ê²½ìš°, ë‹¹ì‹ ì€ ê·¸ê²ƒì„ ê·¸ ì½œë ‰ì…˜ì— ì¶”ê°€í•´ì•¼ 한다. 단순히 <literal>setParent()</literal>를 호출하는 것으로는 충분하지 않다."
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr "케스케ì´ë“œë“¤ê³¼ <literal>unsaved-value</literal>"
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr "우리가 í•˜ë‚˜ì˜ <literal>Session</literal> ì†ì— <literal>Parent</literal>를 ë¡œë“œì‹œì¼°ê³ UI ì•¡ì…˜ì—ì„œ ì–´ë–¤ ë³€ê²½ë“¤ì„ í–‰í–ˆê³ , <literal>update()</literal>를 호출하여 새로운 세션ì—ì„œ ì´ë“¤ ë³€ê²½ë“¤ì„ ì˜ì†í™” 시키는 ê²ƒì„ ì›í•œë‹¤ê³ ê°€ì •í•˜ìž. <literal>Parent</literal>는 ìžì‹ë“¤ì„ 가진 ì½œë ‰ì…˜ì„ í¬í•¨í• 것ì´ê³ , 케스케ì´ë”© ì—…ë°ì´íŠ¸ê°€ 사용 가능하기 때문ì—, Hibernate는 ì–´ëŠ ìžì‹ë“¤ì´ ìƒˆë¡œì´ ì´ˆê¸°í™” ë˜ëŠ”지 ê·¸ë¦¬ê³ ì–´ëŠ ê²ƒì´ ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ 현재 í–‰ë“¤ì„ í‘œí˜„í•˜ëŠ”ì§€ë¥¼ ì•Œ 필요가 있다. <literal>Parent</literal>와 <literal>Child</literal> ëª¨ë‘ <literal>Long</literal> íƒ€ìž…ì˜ ì‹ë³„ìž í”„ë¡œí¼í‹°ë“¤ì„ ìƒì„±ì‹œì¼°ë‹¤ê³ ê°€ì •í•˜ìž. Hibernate는 ì–´ëŠ ìžì‹ë“¤ì´ 새로운 것ì¸ì§€ë¥¼ ê²°ì •í•˜ëŠ”ë° ì‹ë³„ìžì™€ version/timestamp 프로í¼í‹° ê°’ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤.(<xref linkend=\"objectstate-saveorupdate\"/>ì„ ë³´ë¼.) <emphasis>Hibernate!
3ì—서는<literal>unsaved-value</literal>를 ë”ì´ìƒ 명시ì 으로 ì§€ì •í• í•„ìš”ê°€ 없다.</emphasis>"
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr "ë‹¤ìŒ ì½”ë“œëŠ” <literal>parent</literal>와 <literal>child</literal>를 ì—…ë°ì´íŠ¸í•˜ê³ <literal>newChild</literal>를 삽입시킬 것ì´ë‹¤."
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr "ë¬¼ë¡ ê·¸ê²ƒì€ ìƒì„±ë˜ëŠ” ì‹ë³„ìžì˜ 경우ì—는 ëª¨ë‘ ë§¤ìš° 좋지만, í• ë‹¹ë˜ëŠ” ì‹ë³„ìžë“¤ê³¼ composite ì‹ë³„ìžë“¤ì— 대해서는 ì–´ë– í•œê°€? ì´ê²ƒì€ 보다 ì–´ë µë‹¤. 왜ëƒí•˜ë©´ Hibernate는 (사용ìžì— ì˜í•´ í• ë‹¹ëœ ì‹ë³„ìžë¥¼ 가진) ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ ê°ì²´ì™€ ì´ì „ 세션ì—ì„œ 로드ë˜ì—ˆë˜ ê°ì²´ 사ì´ë¥¼ êµ¬ë³„ì§“ëŠ”ë° ì‹ë³„ìž í”„ë¡œí¼í‹°ë¥¼ ì‚¬ìš©í• ìˆ˜ 없기 때문ì´ë‹¤. ì´ ê²½ìš°ì—, Hibernate는 timestamp 프로í¼í‹° ë˜ëŠ” version 프로í¼í‹°ë¥¼ 사용하거나 ì‹¤ì œë¡œ second-level ìºì‹œë¥¼ 질ì˜í•˜ê±°ë‚˜ 가장 ë‚˜ìœ ê²½ìš°ì—는 í–‰ì´ ì¡´ìž¬í•˜ëŠ”ì§€ë¥¼ 알기 위해 ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 질ì˜í• 것ì´ë‹¤."
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr "<title>ê²°ë¡ </title>"
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr "ì—¬ê¸°ì— ìˆ™ì§€í• ê²ƒì´ ì•½ê°„ ìžˆê³ ê·¸ê²ƒì€ ì²˜ìŒì—는 혼ë™ìŠ¤ëŸ¬ìš´ 것처럼 ë³´ì¼ ìˆ˜ 있다. 하지만 ì‹¤ì œë¡œ ê·¸ê²ƒì€ ëª¨ë‘ ë§¤ìš° 좋게 ë™ìž‘한다. ëŒ€ë¶€ë¶„ì˜ Hibernate 어플리케ì´ì…˜ë“¤ì€ ë§Žì€ ìž¥ì†Œë“¤ì—ì„œ 부모/ìžì‹ íŒ¨í„´ì„ ì‚¬ìš©í•œë‹¤."
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr "우리는 첫 번째 단ë½ì—ì„œ ëŒ€ì•ˆì„ ì–¸ê¸‰í–ˆë‹¤. ìœ„ì˜ ìŸì 들 중 ì–´ëŠ ê²ƒë„ ì •í™•í•˜ê²Œ 부모/ìžì‹ ê´€ê³„ì˜ ì˜ë¯¸ë¥¼ 가진, <literal><composite-element></literal> ë§¤í•‘ë“¤ì˜ ê²½ìš°ì—는 존재하지 않는다. 불행히ë„, composite 요소 í´ëž˜ìŠ¤ë“¤ì— 대한 ë‘ ê°œì˜ ì»¤ë‹¤ëž€ ì œì•½ë“¤ì´ ì¡´ìž¬í•œë‹¤: composite ìš”ì†Œë“¤ì€ ì½œë ‰ì…˜ë“¤ì„ ì†Œìœ í•˜ì§€ ì•Šê³ , ê·¸ê²ƒë“¤ì€ ìœ ì¼í•œ 부모가 ì•„ë‹Œ 다른 ì–´ë–¤ ì—”í‹°í‹°ì˜ ìžì‹ì¼ 수는 없다."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,840 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr "ì˜ˆì œ: Weblog 어플리케ì´ì…˜"
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤"
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤ì€ 웹로그, ê·¸ë¦¬ê³ ì›¹ 로그 ë‚´ì— ê²Œì‹œëœ í•ëª©ì„ 표현한다.ê·¸ê²ƒë“¤ì€ í‘œì¤€ 부모/ìžì‹ 관계로 모형화 ë 것ì´ì§€ë§Œ, 우리는 set ëŒ€ì‹ ì— ìˆœì„œì§€ì›Œì§„ bag를 ì‚¬ìš©í• ê²ƒì´ë‹¤."
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr "Hibernate 매핑들"
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr "XML ë§¤í•‘ë“¤ì€ ì´ì œ 매우 간단해질 것ì´ë‹¤."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr "Hibernate 코드"
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr "ë‹¤ìŒ í´ëž˜ìŠ¤ëŠ” 우리가 Hibernate를 사용하여 ì´ë“¤ í´ëž˜ìŠ¤ë“¤ë¡œ í–‰í• ìˆ˜ 있는 몇몇 ì¢…ë¥˜ì˜ ê²ƒë“¤ì„ ì„¤ëª…í•œë‹¤."
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,194 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr "ë°ì´í„° í•„í„°ë§í•˜ê¸°"
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr "Hibernate3ì€ í˜ì‹ ì ì¸ \"가시성(visibility)\" 규칙들로서 ë°ì´í„°ë¥¼ 처리하는 새로운 ì ‘ê·¼ë²•ì„ ì œê³µí•œë‹¤. <emphasis>Hibernate í•„í„°</emphasis>는 íŠ¹ì • Hibernate ì„¸ì…˜ì— ëŒ€í•´ ì´ìš© 가능하게 ë˜ê±°ë‚˜ ì´ìš© 불가능하게 ë ìˆ˜ë„ ìžˆëŠ” ì „ì—, ëª…ëª…ëœ íŒŒë¼ë¯¸í„°í™” ëœ í•„í„°ì´ë‹¤."
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr "Hibernate 필터들"
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr "Hibernate3ì€ í•„í„° 기준(criteria)ì„ ë¯¸ë¦¬ ì •ì˜í•˜ê³ í´ëž˜ìŠ¤ ë ˆë²¨ê³¼ ì½œë ‰ì…˜ ë ˆë²¨ ì–‘ìžì—ì„œ 그들 í•„í„°ë“¤ì„ ì²¨ë¶€í• ëŠ¥ë ¥ì„ ì¶”ê°€ì‹œí‚¨ë‹¤. í•„í„° 기준(criteria)ì€ í´ëž˜ìŠ¤ 요소와 다양한 ì½œë ‰ì…˜ ìš”ì†Œë“¤ì— ëŒ€í•´ ì´ìš© 가능한 ê¸°ì¡´ì˜ \"where\" ì†ì„±ê³¼ 매우 ìœ ì‚¬í•œ í•˜ë‚˜ì˜ ì œí•œ ì ˆì„ ì •ì˜í•˜ëŠ” ëŠ¥ë ¥ì´ë‹¤. ì´ê²ƒë“¤ì„ ì œì™¸í•˜ë©´ í•„í„° ì¡°ê±´ë“¤ì€ íŒŒë¼ë¯¸í„°í™” ë 수 있다. 그때 어플리케ì´ì…˜ì€ 주어진 í•„í„°ë“¤ì´ ì´ìš© 가능한지 여부 ê·¸ë¦¬ê³ ê·¸ë“¤ 파ë¼ë¯¸í„° ê°’ë“¤ì´ ë¬´ì—‡ì´ì–´ì•¼ 하는지를 실행 ì‹œì— ê²°ì •í• ìˆ˜ 있다. í•„í„°ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ 뷰들 처럼 사용ë 수 있지만, 어플리케ì´ì…˜ ë‚´ë¶€ì— íŒŒë¼ë¯¸í„°í™” ëœë‹¤."
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr "í•„í„°ë“¤ì„ ì‚¬ìš©í•˜ê¸° 위해서, ê·¸ê²ƒë“¤ì€ ë¨¼ì € ì •ì˜ë˜ê³ 나서 ì ì ˆí•œ 매핑 ìš”ì†Œë“¤ì— ì²¨ê°€ë˜ì–´ì•¼ 한다. 필터를 ì •ì˜í•˜ê¸° 위해, <literal><hibernate-mapping/></literal> 요소 ë‚´ë¶€ì— <literal><filter-def/></literal> 요소를 사용하ë¼:"
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr "그때 ì´ í•„í„°ëŠ” í´ëž˜ìŠ¤ì— 첨가ë 수 있다:"
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr "ë˜ëŠ” ì½œë ‰ì…˜ì— ì²¨ê°€ë 수 있다:"
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr "ë˜ëŠ” ë™ì‹œì— ì–‘ìžì—(ë˜ëŠ” ê°ê°ì˜ 여러번) 첨가ë 수 있다."
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr "<literal>Session</literal> ìƒì˜ ë©”ì†Œë“œë“¤ì€ ë‹¤ìŒê³¼ 같다: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, <literal>disableFilter(String filterName)</literal>. ë””í´íŠ¸ë¡œ, í•„í„°ë“¤ì€ ì£¼ì–´ì§„ ì„¸ì…˜ì— ëŒ€í•´ ì´ìš© 가능하지 <emphasis>않다</emphasis>; ê·¸ê²ƒë“¤ì€ <literal>Session.enabledFilter()</literal> ë©”ì†Œë“œì˜ ì‚¬ìš©ì„ í†µí•´ 명시ì 으로 ì´ìš© 가능하게 ë˜ì–´ì•¼ 한다. <literal>Session.enabledFilter()</literal>는 <literal>Filter</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 반환한다. ìœ„ì— ì •ì˜ëœ 간단한 필터를 사용하면, ì´ê²ƒì€ 다ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr "org.hibernate.Filter ì¸í„°íŽ˜ì´ìŠ¤ ìƒì˜ ë©”ì†Œë“œë“¤ì€ Hibernateì— ë§¤ìš° ê³µí†µëœ method-chainingì„ í—ˆìš©í•œë‹¤ëŠ” ì ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr "ìœ íš¨í•œ ê¸°ë¡ ë‚ ì§œ íŒ¨í„´ì„ ê°€ì§„ 시간 ë°ì´í„°ë¥¼ 사용하는 ì „ì²´ ì˜ˆì œ :"
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr "그때 ë‹¹ì‹ ì´ í˜„ìž¬ ìœ íš¨í•œ ë ˆì½”ë“œë“¤ì„ í•ìƒ 얻는 ê²ƒì„ í™•ì‹¤ížˆ 하기 위해, employee ë°ì´í„°ë¥¼ 검색하기 ì „ì— ì„¸ì…˜ ìƒì— 필터를 간단하게 ì´ìš© 가능하게 하ë¼:"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr "ìœ„ì˜ HQL ì—ì„œ, 심지어 ë¹„ë¡ ìš°ë¦¬ê°€ ê²°ê³¼ë“¤ì— ëŒ€í•œ 봉급 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ 명시ì 으로 언급만 í–ˆì„지ë¼ë„, ì´ìš© 가능한 í•„í„° ë•Œë¬¸ì— ê·¸ 질ì˜ëŠ” ë´‰ê¸‰ì´ ë°±ë§Œë‹¬ëŸ¬ ì´ìƒì¸ 현재 ì±„ìš©ì¤‘ì¸ ì§ì›ë“¤ë§Œì„ ë°˜í™˜í• ê²ƒì´ë‹¤."
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr "노트: ë§Œì¼ ë‹¹ì‹ ì´ outer ì¡°ì¸ì— 대해 í•„í„°ë“¤ì„ ì‚¬ìš©í• ê³„íšì´ë¼ë©´ (HQLì´ë“ 로드 페ì¹ì´ë“ ) ì¡°ê±´ 표현ì‹ì˜ ë°©í–¥ì„ ì£¼ì˜í•˜ë¼. ì´ê²ƒì„ left outer join으로 ì„¤ì •í•˜ëŠ” ê²ƒì´ ê°€ìž¥ ì•ˆì „í•˜ë‹¤; ì¼ë°˜ì 으로 오í¼ë ˆì´í„° ë’¤ì— ìžˆëŠ” 컬럼 ì´ë¦„(들)ì´ ë’¤ë”°ë¥´ëŠ” ì²«ë²ˆì§¸ì— íŒŒë¼ë¯¸í„°ë¥¼ 위치지워ë¼."
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr "í•„í„°ê°€ ì •ì˜ëœ 후ì—는 그것 ìžì‹ ì˜ ì¡°ê±´ì— ëŒ€í•´ ê°ê° 여러 ê°œì˜ ì—”í‹°í‹°ë“¤ ê·¸ë¦¬ê³ /ë˜ëŠ” ì½œë ‰ì…˜ë“¤ì— ì²¨ê°€ë 수 있다. ì¡°ê±´ë“¤ì´ ë§¤ë²ˆ ë™ì¼í• ë•Œ ê·¸ê²ƒì€ ì§€ë£¨í• ìˆ˜ 있다. ë”°ë¼ì„œ <literal><filter-def/></literal>ì€ attribute ë“ CDATA ë“ ì–´ëŠê²ƒì´ë“ ë””í´íŠ¸ ì¡°ê±´ì„ ì •ì˜í•˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤:"
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr "그때 ì´ ë””í´íŠ¸ ì¡°ê±´ì€ ê·¸ í•„í„°ê°€ ì–´ë–¤ ì¡°ê±´ì„ ì§€ì •í•¨ì´ ì—†ì´ ì–´ë–¤ ê²ƒì— ì²¨ê°€ë 때마다 사용ë 수 있다. ì´ê²ƒì€ ë‹¹ì‹ ì´ íŠ¹ì •í•œ ê²½ìš°ì— ë””í´íŠ¸ ì¡°ê±´ì„ ì˜¤ë²„ë¼ì´ë“œ 시키는 í•„í„°ì˜ ì²¨ê°€ 부분으로서 íŠ¹ì • ì¡°ê±´ì„ ë¶€ì—¬í• ìˆ˜ 있ìŒì„ ì˜ë¯¸í•¨ì„ 노트하ë¼."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,642 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr "ìƒì† 매핑"
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr "세 가지 ë°©ë„들"
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr "Hibernate는 세 가지 기본ì ì¸ ìƒì† 매핑 ë°©ë„ë“¤ì„ ì§€ì›í•œë‹¤:"
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr "table per class hierarchy"
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr "<para>table per subclass</para>"
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr "table per concrete class"
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr "게다가 Hibernate는 네 ë²ˆì§¸ì˜ ì•½ê°„ 다른 ì¢…ë¥˜ì˜ ë‹¤í˜•ì„±ì„ ì§€ì›í•œë‹¤:"
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr "implicit polymorphism(함축ì ì¸ ë‹¤í˜•ì„±)"
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr "ë™ì¼í•œ ìƒì† ê³„ì¸µêµ¬ì¡°ì˜ ë‹¤ë¥¸ ê°€ì§€ë“¤ì— ëŒ€í•´ 다른 매핑 ë°©ë„ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì´ ê°€ëŠ¥í•˜ê³ , 그런 ë‹¤ìŒ ì „ì²´ 계층 구조를 가로질러 ë‹¤í˜•ì„±ì„ ì„±ì·¨í•˜ëŠ”ë° í•¨ì¶•ì ì¸ ë‹¤í˜•ì„±ì„ ì‚¬ìš©í•˜ë¼. 하지만 Hibernate는 ë™ì¼í•œ 루트 <literal><class></literal> 요소 하ì—ì„œ <literal><subclass></literal> ê·¸ë¦¬ê³ <literal><joined-subclass></literal> ê·¸ë¦¬ê³ <literal><union-subclass></literal> ë§¤í•‘ë“¤ì„ í˜¼í•©í•˜ëŠ” ê²ƒì„ ì§€ì›í•˜ì§€ 않는다. ë™ì¼í•œ <literal><class></literal> 요소 하ì—ì„œ <literal><subclass></literal> 요소와 <literal><join></literal> 요소를 ê²°í•©ì‹œí‚´ìœ¼ë¡œì¨ table per hierarchy ë°©ë„와 table per subclass ë°©ë„를 함께 혼합시키는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤(아래를 ë³´ë¼)."
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter 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> ë§¤í•‘ë“¤ì„ ì •ì˜í•˜ëŠ” ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. ì´ê²ƒì€ 단지 í•˜ë‚˜ì˜ ìƒˆë¡œìš´ 매핑 파ì¼ì„ 추가시켜서 í•˜ë‚˜ì˜ class 계층구조를 확장하는 ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다. ë‹¹ì‹ ì€ subclass 매핑 ë‚´ì— ì•žì„œ ë§¤í•‘ëœ ìŠˆí¼í´ëž˜ìŠ¤ë¥¼ 명명하여 <literal>extends</literal> ì†ì„±ì„ ì§€ì •í•´ì•¼ 한다. 노트 : 명백하게 ì´ íŠ¹ì§•ì€ ë§¤í•‘ ë¬¸ì„œë“¤ì˜ ìˆœì„œë¥¼ ì¤‘ìš”í•˜ê²Œë” ë§Œë“¤ì—ˆë‹¤. Hibernate3 ì´í›„ë¡œ, 매핑 파ì¼ë“¤ì˜ 순서는 extends 키워드를 ì‚¬ìš©í• ë•Œ ìƒê´€ì—†ë‹¤. í•˜ë‚˜ì˜ ë§¤í•‘ íŒŒì¼ ë‚´ì˜ ìˆœì„œëŠ” ì—¬ì „ížˆ 서브í´ëž˜ìŠ¤ë“¤ì— ì•žì„œ 슈í¼í´ëž˜ìŠ¤ë“¤ì„ ì •ì˜í•˜ëŠ”ë° ì—¬ì „ížˆ 필요하다."
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr "Table per class hierarchy"
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr "우리가 <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal> 구현ìžë“¤ì„ 가진 í•˜ë‚˜ì˜ ì¸í„°íŽ˜ì´ìŠ¤ <literal>Payment</literal>를 ê°–ê³ ìžˆë‹¤ê³ ê°€ì •í•˜ìž. table per hierarchy ë§¤í•‘ì€ ë‹¤ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr "ì •í™•ížˆ í•˜ë‚˜ì˜ í…Œì´ë¸”ì´ í•„ìš”í•˜ë‹¤. ì´ ë§¤í•‘ ë°©ë„ì—는 다ìŒì˜ í•˜ë‚˜ì˜ í° ì œì•½ì´ ì¡´ìž¬í•œë‹¤: <literal>CCTYPE</literal>ê³¼ ê°™ì´, 서브 í´ëž˜ìŠ¤ë“¤ì— ì˜í•´ ì„ ì–¸ëœ ì»¬ëŸ¼ë“¤ì€ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ì„ 가질 수 없다."
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr "Table per subclass"
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr "table per subclass ë§¤í•‘ì€ ë‹¤ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:102
+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 "네 ê°œì˜ í…Œì´ë¸”ë“¤ì´ í•„ìš”í•˜ë‹¤. 세 ê°œì˜ ì„œë¸Œí´ëž˜ìŠ¤ í…Œì´ë¸”ë“¤ì€ ìŠˆí¼í´ëž˜ìŠ¤ í…Œì´ë¸”ì— ëŒ€í•œ 프ë¼ì´ë¨¸ë¦¬ 키 ì—°ê´€ë“¤ì„ ê°–ëŠ”ë‹¤ (ë”°ë¼ì„œ ê·¸ 관계형 ëª¨í˜•ì€ ì‹¤ì œë¡œ one-to-one ì—°ê´€ì´ë‹¤)."
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr "discriminator를 사용하는, table per subclass"
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr "table-per-subclassì— ëŒ€í•œ Hibernateì˜ êµ¬í˜„ì€ discriminator(íŒë³„ìž) ì»¬ëŸ¼ì„ í•„ìš”ë¡œ 하지 ì•ŠìŒì„ 노트하ë¼. 다른 ê°ì²´/관계형 ë§¤í•‘ê¸°ë“¤ì€ ìŠˆí¼í´ëž˜ìŠ¤ í…Œì´ë¸” ì†ì— í•˜ë‚˜ì˜ íƒ€ìž… íŒë³„ìž ì»¬ëŸ¼ì„ í•„ìš”ë¡œ 하는 table-per-subclassì— ëŒ€í•œ 다른 êµ¬í˜„ì„ ì‚¬ìš©í•œë‹¤. Hibernateì— ì˜í•´ 채íƒëœ ì ‘ê·¼ë²•ì€ êµ¬í˜„í•˜ê¸°ê°€ 훨씬 ë” ì–´ë µì§€ë§Œ 관계형 ê´€ì ì—서는 아마 í‹€ë¦¼ì—†ì´ ë³´ë‹¤ ë” ì •í™•í•˜ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ table per subclass ë°©ë„ì— ëŒ€í•´ í•˜ë‚˜ì˜ íŒë³„ìž ì»¬ëŸ¼ì„ ì‚¬ìš©í•˜ê³ ì‹¶ë‹¤ë©´, ë‹¹ì‹ ì€ ë‹¤ìŒê³¼ ê°™ì´ <literal><subclass></literal>와 <literal><join></literal>ì˜ ì‚¬ìš©ì„ ê²°í•©ì‹œí‚¬ ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:127
+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> ì„ ì–¸ì€ ìŠˆí¼í´ëž˜ìŠ¤ë¥¼ 질ì˜í• ë•Œ outer joinì„ ì‚¬ìš©í•˜ì—¬ <literal>ChequePayment</literal> 서브í´ëž˜ìŠ¤ ë°ì´í„°ë¥¼ 페치시키지 ì•Šë„ë¡ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤."
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr "table per class hierarchy와 table per subclass를 혼합하기"
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr "ë‹¹ì‹ ì€ ì´ ì ‘ê·¼ë²•ì„ ì‚¬ìš©í•˜ì—¬ table per hierarchy ë°©ë„와 table per subclass ë°©ë„를 혼합시킬 수 있다:"
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr "ì´ë“¤ 매핑 ë°©ë„들 중 ì–´ë–¤ ê²ƒì— ëŒ€í•´, 루트 <literal>Payment</literal> í´ëž˜ìŠ¤ì— 대한 í•˜ë‚˜ì˜ ë‹¤í˜•ì„± ì—°ê´€ì€ <literal><many-to-one></literal>ì„ ì‚¬ìš©í•˜ì—¬ 매핑ëœë‹¤."
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr "Table per concrete class"
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr "우리가 table per concrete class ë°©ë„ ë§¤í•‘ì— ëŒ€í•´ ì·¨í• ìˆ˜ 있는 ë‘ ê°€ì§€ ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤. 첫 번째는 <literal><union-subclass></literal>를 사용하는 것ì´ë‹¤."
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr "세 ê°œì˜ í…Œì´ë¸”ë“¤ì´ ìŠˆí¼í´ëž˜ìŠ¤ë“¤ì— 대해 수반ëœë‹¤. ê°ê°ì˜ í…Œì´ë¸”ì€ ìƒì†ëœ 프로í¼í‹°ë“¤ì„ í¬í•¨í•˜ì—¬, ê·¸ í´ëž˜ìŠ¤ì˜ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤ì— 대한 ì»¬ëŸ¼ë“¤ì„ ì •ì˜í•œë‹¤."
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr "ì´ ì ‘ê·¼ë²•ì˜ ì œì•½ì€ ë§Œì¼ í•˜ë‚˜ì˜ í”„ë¡œí¼í‹°ê°€ 슈í¼í´ëž˜ìŠ¤ ìƒìœ¼ë¡œ 매핑ë 경우, ê·¸ 컬럼 ì´ë¦„ì´ ëª¨ë“ ì„œë¸Œí´ëž˜ìŠ¤ í…Œì´ë¸”들 ìƒì—ì„œ 같아야 한다는 ì ì´ë‹¤.(ìž¥ëž˜ì˜ Hibernate ë°°í¬ë³¸ì—ì„œ 우리는 ì´ ì œì•½ì„ í’€ ìˆ˜ë„ ìžˆë‹¤.) identity ìƒì„±ê¸° ë°©ë„는 union 서브í´ëž˜ìŠ¤ ìƒì†ì—ì„œ 허용ë˜ì§€ 않으며, ì§„ì • 프ë¼ì´ë¨¸ë¦¬ 키 시드는 í•˜ë‚˜ì˜ ê³„ì¸µêµ¬ì¡°ì˜ ëª¨ë“ unioned 서브í´ëž˜ìŠ¤ë“¤ì„ 가로질러 ê³µìœ ë˜ì–´ì•¼ 한다."
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ìŠˆí¼í´ëž˜ìŠ¤ê°€ abstractì¼ ê²½ìš°ì—, ê·¸ê²ƒì„ <literal>abstract=\"true\"</literal>ë¡œ 매핑하ë¼. ë¬¼ë¡ ë§Œì¼ ê·¸ê²ƒì´ abstractê°€ ì•„ë‹ ê²½ìš°, 추가ì ì¸ í…Œì´ë¸”(ìœ„ì˜ ì˜ˆì œì—서는 ë””í´íŠ¸ë¡œ <literal>PAYMENT</literal>)ì´ ìŠˆí¼í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ì†Œìœ í•˜ëŠ”ë° í•„ìš”í•˜ë‹¤."
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr "함축ì ì¸ ë‹¤í˜•ì„±ì„ ì‚¬ìš©í•˜ëŠ”, table per concrete class"
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr "대안ì ì¸ ì ‘ê·¼ë²•ì€ í•¨ì¶•ì ì¸ ë‹¤í˜•ì„±ì„ ì‚¬ìš©í•˜ëŠ” 것ì´ë‹¤:"
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr "ì–´ëŠ ê³³ì—ì„œë„ ìš°ë¦¬ê°€ 명시ì 으로 <literal>Payment</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 언급하지 ì•ŠìŒì„ 주목하ë¼. ë˜í•œ <literal>Payment</literal>ì˜ í”„ë¡œí¼í‹°ë“¤ì´ 서브í´ëž˜ìŠ¤ë“¤ ê°ê°ì—ì„œ 매핑ëœë‹¤ëŠ” ì ì„ ì£¼ëª©í•˜ë¼. ë§Œì¼ ë‹¹ì‹ ì´ ì¤‘ë³µì„ í”¼í•˜ê³ ìž ì›í•œë‹¤ë©´, XML ì—”í‹°í‹°ë“¤ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ê³ ë ¤í•˜ë¼(예를 들어 매핑ì—ì„œ <literal>DOCTYPE</literal> ì„ ì–¸ê³¼ <literal>&allproperties;</literal>ì—ì„œ <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal>)."
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr "ì´ ì ‘ê·¼ë²•ì˜ ë‹¨ì ì€ ë‹¤í˜•ì„± 질ì˜ë“¤ì„ ìˆ˜í–‰í• ë•Œ Hibernateê°€ ìƒì„±ëœ SQl <literal>UNION</literal>ë“¤ì„ ìƒì„±ì‹œí‚¤ëŠ” 않는다는 ì ì´ë‹¤."
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr "ì´ ë§¤í•‘ ë°©ë„ì˜ ê²½ìš°, <literal>Payment</literal>ì— ëŒ€í•œ í•˜ë‚˜ì˜ ë‹¤í˜•ì„± ì—°ê´€ì€ ëŒ€ê°œ <literal><any></literal>를 사용하여 매핑ëœë‹¤."
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr "함축ì ì¸ ë‹¤í˜•ì„±ì„ ë‹¤ë¥¸ ìƒì† 매핑들과 혼합하기"
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr "ì´ ë§¤í•‘ì— ëŒ€í•´ ì£¼ëª©í• í•˜ë‚˜ ì´ìƒì˜ ê²ƒì´ ì¡´ìž¬í•œë‹¤. 서브í´ëž˜ìŠ¤ë“¤ì´ 그것들 ìžì‹ ì˜<literal><class></literal> 요소 ë‚´ì— ê°ê° 매핑ë˜ë¯€ë¡œ(ê·¸ë¦¬ê³ <literal>Payment</literal>ê°€ 단지 ì¸í„°íŽ˜ì´ìŠ¤ì´ë¯€ë¡œ), 서브í´ëž˜ìŠ¤ë“¤ ê°ê°ì€ 쉽게 ë˜ ë‹¤ë¥¸ ìƒì† ê³„ì¸µêµ¬ì¡°ì˜ ë¶€ë¶„ì¼ ìˆ˜ 있다! (ê·¸ë¦¬ê³ ë‹¹ì‹ ì€ <literal>Payment</literal> ì¸í„°íŽ˜ì´ìŠ¤ì— 대해 ì—¬ì „ížˆ 다형성 질ì˜ë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있다.)"
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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> ì¸í„°íŽ˜ì´ìŠ¤ì— 대해 í•˜ë‚˜ì˜ ì§ˆì˜ë¥¼ ì‹¤í–‰í• ê²½ìš°-예를 들어, from Payment-, Hibernate는 <literal>CreditCardPayment</literal> (와 ê·¸ê²ƒì˜ ì„œë¸Œí´ëž˜ìŠ¤ë“¤, 왜ëƒí•˜ë©´ 그것들 ë˜í•œ <literal>Payment</literal>를 구현하므로), <literal>CashPayment</literal> ê·¸ë¦¬ê³ <literal>ChequePayment</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ìžë™ì 으로 ë°˜í™˜í• ê²ƒì´ì§€ë§Œ <literal>NonelectronicTransaction</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 반환하지 않는다."
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr "<title>ì œì•½ë“¤</title>"
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr "table per concrete-class 매핑 ë°©ë„ì— ëŒ€í•œ \"함축ì ì¸ ë‹¤í˜•ì„±\" ì ‘ê·¼ë²•ì—는 ì–´ë–¤ ì œì•½ë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal><union-subclass></literal> ë§¤í•‘ë“¤ì— ëŒ€í•´ì„œëŠ” 다소 ëœ ì œí•œì ì¸ ì œì•½ë“¤ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr "ë‹¤ìŒ í‘œëŠ” Hibernateì—ì„œ table per concrete-class ë§¤í•‘ë“¤ì— ëŒ€í•œ ì œì•½ë“¤, ê·¸ë¦¬ê³ í•¨ì¶•ì ì¸ ë‹¤í˜•ì„±ì— ëŒ€í•œ ì œì•½ë“¤ì„ ë³´ì—¬ì¤€ë‹¤."
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr "ìƒì† ë§¤í•‘ë“¤ì˜ íŠ¹ì§•ë“¤"
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr "ìƒì† ë°©ë„"
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr "다형성 다대ì¼"
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr "다형성 ì¼ëŒ€ì¼"
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr "다형성 ì¼ëŒ€ë‹¤"
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr "다형성 다대다"
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr "다형성 <literal>load()/get()</literal>"
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr "다형성 질ì˜ë“¤"
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr "다형성 ì¡°ì¸ë“¤"
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr "Outer ì¡°ì¸ íŽ˜ì¹"
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr "table per class-hierarchy"
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr "<many-to-one>"
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr "<one-to-one>"
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr "<one-to-many>"
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr "<many-to-many>"
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr "s.get(Payment.class, id)"
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr "from Payment p"
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr "from Order o join o.payment p"
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr "<emphasis>지ì›ë¨</emphasis>"
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr "<entry>table per subclass</entry>"
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr "table per concrete-class (union-subclass)"
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr "table per concrete class (implicit polymorphism)"
+
+#: index.docbook:323
+msgid "<any>"
+msgstr "<any>"
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr "지ì›ë˜ì§€ ì•ŠìŒ"
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr "<many-to-any>"
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1220 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr "í¼í¬ë¨¼ìŠ¤ ê°œì„ í•˜ê¸°"
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr "íŽ˜ì¹ ë°©ë„들"
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr "<emphasis>íŽ˜ì¹ ë°©ë„</emphasis>는 어플리케ì´ì…˜ì´ ì—°ê´€ì„ ë„¤ë¹„ê²Œì´íŠ¸í• 필요가 ìžˆì„ ë•Œ Hibernateê°€ ì—°ê´€ëœ ê°ì²´ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©í•˜ê²Œ ë ë°©ë„ì´ë‹¤.페치 ë°©ë„ë“¤ì€ O/R 매핑 메타ë°ì´í„° ë‚´ì—ì„œ ì„ ì–¸ë 수 있거나 í•˜ë‚˜ì˜ íŠ¹ì • HQL ë˜ëŠ” <literal>Criteria</literal> 질ì˜ì— ì˜í•´ 오버ë¼ì´ë“œ ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr "Hibernate3는 ë‹¤ìŒ íŽ˜ì¹ ë°©ë„ë“¤ì„ ì •ì˜í•œë‹¤:"
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr "<emphasis>Join 페ì¹</emphasis> - Hibernate는 <literal>OUTER JOIN</literal>ì„ ì‚¬ìš©í•˜ì—¬ ì—°ê´€ëœ ì¸ìŠ¤í„´ìŠ¤ ë˜ëŠ” ë™ì¼í•œ <literal>SELECT</literal> ë‚´ì—ì„œ ì½œë ‰ì…˜ì„ ê²€ìƒ‰í•œë‹¤."
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Select 페ì¹</emphasis> - ë‘ ë²ˆì§¸ <literal>SELECT</literal>는 ì—°ê³¼ëœ ì—”í‹°í‹° ë˜ëŠ” ì½œë ‰ì…˜ì„ ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤. ë‹¹ì‹ ì´ <literal>lazy=\"false\"</literal>를 ì§€ì •í•¨ìœ¼ë¡œì¨ ëª…ì‹œì 으로 lazy 페ì¹ì„ 사용 불가능하게 하지 않는 í•œ, ì´ ë‘ ë²ˆì§¸ select는 ë‹¹ì‹ ì´ ê·¸ ì—°ê´€ì— ì‹¤ì œë¡œ ì•¡ì„¸ìŠ¤í• ë•Œ ì˜¤ì§ ì‹¤í–‰ë 것ì´ë‹¤."
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr "<emphasis>Subselect 페ì¹</emphasis> - ë‘ ë²ˆì§¸ <literal>SELECT</literal>는 ì´ì „ ì§ˆì˜ ë˜ëŠ” 페치ì—ì„œ ê²€ìƒ‰ëœ ëª¨ë“ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ ì—°ê´€ëœ ì½œë ‰ì…˜ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤. ë‹¹ì‹ ì´ <literal>lazy=\"false\"</literal>를 ì§€ì •í•˜ì—¬ 명시ì 으로 lazy 페ì¹ì„ 사용 불가능하게 하지 않는 í•œ, ì´ ë‘ ë²ˆì§¸ select는 ë‹¹ì‹ ì´ ì‹¤ì œë¡œ ê·¸ ì—°ê´€ì— ì ‘ê·¼í• ë•Œ ì˜¤ì§ ì‹¤í–‰ë 것ì´ë‹¤."
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr "<emphasis>Batch 페ì¹</emphasis> - select 페ì¹ì„ 위한 최ì í™” ë°©ë„ - Hibernate는 프ë¼ì´ë¨¸ë¦¬ 키들ì´ë‚˜ foreign í‚¤ë“¤ì˜ ë¦¬ìŠ¤íŠ¸ë¥¼ ì§€ì •í•¨ìœ¼ë¡œì¨ í•˜ë‚˜ì˜<literal>SELECT</literal> ë‚´ì—ì„œ 엔티티 ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ë‚˜ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ batch를 검색한다."
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr "Hibernate는 ë˜í•œ ë‹¤ìŒ ì‚¬ì´ë¥¼ 구별 짓는다:"
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr "<emphasis>즉ê°ì ì¸ íŽ˜ì¹</emphasis> - ì†Œìœ ìžê°€ 로드ë ë•Œ, ì—°ê´€, ì½œë ‰ì…˜ ë˜ëŠ” ì†ì„±ì´ 즉시 페치ëœë‹¤."
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr "<emphasis>Lazy ì½œë ‰ì…˜ 페ì¹</emphasis> - 어플리케ì´ì…˜ì´ ê·¸ ì½œë ‰ì…˜ì— ëŒ€í•´ í•˜ë‚˜ì˜ ì˜¤í¼ë ˆì´ì…˜ì„ í˜¸ì¶œí• ë•Œ ì½œë ‰ì…˜ì´ íŽ˜ì¹˜ëœë‹¤.(ì´ê²ƒì€ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ ë””í´íŠ¸ì´ë‹¤.)"
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr "<emphasis>\"Extra-lazy\" ì½œë ‰ì…˜ 페ì¹</emphasis> - ì½œë ‰ì…˜ì˜ ê°œë³„ ìš”ì†Œë“¤ì€ í•„ìš”í• ë•Œ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ì ‘ê·¼ëœë‹¤. Hibernate는 ì ˆëŒ€ì 으로 필요하지 ì•Šì€ í•œ ì „ì²´ ì½œë ‰ì…˜ì„ ë©”ëª¨ë¦¬ ë‚´ë¡œ íŽ˜ì¹˜í•˜ë ¤ê³ ì‹œë„하지 않는다(매우 í° ì½œë ‰ì…˜ì— ì 합함)"
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr "<emphasis>프ë½ì‹œ 페ì¹</emphasis> - ì‹ë³„ìž getterê°€ ì•„ë‹Œ 다른 메소드가 ì—°ê´€ëœ ê°ì²´ì— 대해 호출ë ë•Œ ë‹¨ì¼ ê°’ ì—°ê´€ì´ íŽ˜ì¹˜ëœë‹¤."
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>\"No-proxy\" 페ì¹</emphasis> - ì¸ìŠ¤í„´ìŠ¤ 변수가 ì ‘ê·¼ë ë•Œ ë‹¨ì¼ ê°’ ì—°ê´€ì´ íŽ˜ì¹˜ëœë‹¤. 프ë½ì‹œ 페ì¹ê³¼ 비êµí• ë•Œ, ì´ ì ‘ê·¼ë²•ì€ ë‹¤ì†Œ ëœ lazy하지만(ê·¸ ì—°ê´€ì€ ì‹¬ì§€ì–´ ìœ ì¼í•˜ê²Œ ì‹ë³„ìžê°€ ì ‘ê·¼ë ë•Œì—ë„ íŽ˜ì¹˜ëœë‹¤)보다 투명하다. 왜ëƒí•˜ë©´ 프ë½ì‹œëŠ” 어플리케ì´ì…˜ì— 가시ì ì´ì§€ 않기 때문ì´ë‹¤. ì´ ì ‘ê·¼ë²•ì€ ë¹Œë“œ ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 하며 드물게 필요하다."
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>Lazy ì†ì„± 페ì¹</emphasis> - ì¸ìŠ¤í„´ìŠ¤ 변수가 ì ‘ê·¼ë ë•Œ ì†ì„± ë˜ëŠ” ë‹¨ì¼ ê°’ ì—°ê´€ì´ íŽ˜ì¹˜ëœë‹¤ ì´ ì ‘ê·¼ë²•ì€ ë¹Œë“œì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 하며 드물게 필요하다."
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr "우리는 여기서 ë‘ ê°œì˜ ì§êµí•˜ëŠ” ê°œë…ë“¤ì„ ê°–ëŠ”ë‹¤: ì—°ê´€ì´ íŽ˜ì¹˜ë <emphasis>ë•Œ</emphasis>, ê·¸ë¦¬ê³ ê·¸ê²ƒì´ íŽ˜ì¹˜ë˜ëŠ” <emphasis>방법</emphasis>(사용ë˜ëŠ” SQL). ê·¸ê²ƒë“¤ì„ í˜¼ë™í•˜ì§€ ë§ë¼! 우리는 í¼í¬ë¨¼ìŠ¤ë¥¼ íŠœíŒ…í•˜ëŠ”ë° <literal>페치</literal>를 사용한다. 우리는 íŠ¹ì • í´ëž˜ìŠ¤ì˜ ì–´ë–¤ detached ì¸ìŠ¤í„´ìŠ¤ ë‚´ì—ì„œ í•ìƒ ì´ìš© 가능한 ë°ì´í„°ê°€ 무엇ì¸ì§€ì— 대한 ê³„ì•½ì„ ì •ì˜í•˜ëŠ”ë° <literal>lazy</literal>를 ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr "lazy 연관들로 작업하기"
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr "ë””í´íŠ¸ë¡œ Hibernate3는 ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ lazy select 페ì¹ì„ ì‚¬ìš©í•˜ê³ , ë‹¨ì¼ ê°’ ì—°ê´€ë“¤ì— ëŒ€í•´ lazy 프ë½ì‹œ 페ì¹ì„ 사용한다. ì´ë“¤ ë””í´íŠ¸ë“¤ì€ ê±°ì˜ ëª¨ë“ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì—ì„œ ê±°ì˜ ëª¨ë“ ì—°ê´€ë“¤ì— ëŒ€í•´ ìœ ì˜ë¯¸í•˜ë‹¤."
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr "<emphasis>노트:</emphasis> ë§Œì¼ ë‹¹ì‹ ì´ <literal>hibernate.default_batch_fetch_size</literal>를 ì„¤ì •í•˜ëŠ” 경우, Hibernate는 lazy 페ì¹ì„ 위한 batch 페치 최ì 화를 ì‚¬ìš©í• ê²ƒì´ë‹¤(ì´ ìµœì 화는 ë˜í•œ ë” ë§Žì€ ê³¼ë¦½ìƒì˜ ë ˆë²¨ì—ì„œ ì´ìš© ê°€ëŠ¥í• ìˆ˜ 있다)."
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr "하지만, lazy 페ì¹ì€ ë‹¹ì‹ ì´ ì•Œê³ ìžˆì–´ì•¼ 하는 í•œ 가지 ë¬¸ì œë¥¼ ì œê¸°í•œë‹¤. ì—´ë ¤ì§„ Hibernate 세션 컨í…스트 외부ì—ì„œ lazy ì—°ê´€ì— ëŒ€í•œ ì ‘ê·¼ì€ ì˜ˆì™¸ìƒí™©ìœ¼ë¡œ 귀결ë 것ì´ë‹¤. 예를 들면 :"
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr "<literal>Session</literal>ì´ ë‹«í˜”ì„ ë•Œ permissions ì½œë ‰ì…˜ì´ ì´ˆê¸°í™” ë˜ì§€ 않았으므로, ê·¸ ì½œë ‰ì…˜ì€ ê·¸ê²ƒì˜ ìƒíƒœë¥¼ 로드시킬 수가 ì—†ì„ ê²ƒì´ë‹¤. <emphasis>Hibernate 는 detached ê°ì²´ë“¤ì— 대한 lazy 초기화를 지ì›í•˜ì§€ 않는다.</emphasis> ì •ì •ì€ ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° ì½ì–´ë“¤ì´ëŠ” 코드를 커밋 바로 ì§ì „으로 ì´ë™ì‹œí‚¤ëŠ” 것ì´ë‹¤."
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr "다른 방법으로 ì—°ê´€ ë§¤í•‘ì— ëŒ€í•´ <literal>lazy=\"false\"</literal>를 ì§€ì •í•¨ìœ¼ë¡œì¨, non-lazy ì½œë ‰ì…˜ ë˜ëŠ” non-lazy ì—°ê´€ì„ ì‚¬ìš©í• ìˆ˜ 있다. 하지만 lazy 초기화는 ê±°ì˜ ëª¨ë“ ì½œë ‰ì…˜ë“¤ê³¼ ì—°ê´€ë“¤ì— ëŒ€í•´ 사용ë˜ë„ë¡ ê³ ì•ˆë˜ì–´ 있다. ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ê°ì²´ 모형 ë‚´ì— ë„ˆë¬´ ë§Žì€ non-lazy ì—°ê´€ë“¤ì„ ì •ì˜í• 경우, Hibernate는 ëª¨ë“ íŠ¸ëžœìžì…˜ì—ì„œ ì „ì²´ ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 메모리 ì†ìœ¼ë¡œ 페치하는 í•„ìš”ì„±ì„ ë내게 ë 것ì´ë‹¤!"
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr "다른 한편으로, 우리는 íŠ¹ì • 트랜ìžì…˜ ë‚´ì—ì„œ select íŽ˜ì¹ ëŒ€ì‹ ì— (ê³ ìœ í•˜ê²Œ non-lazyì¸) join 페ì¹ì„ ì„ íƒí•˜ê¸°ë¥¼ ìžì£¼ ì›í•œë‹¤. 우리는 ì´ì œ íŽ˜ì¹ ë°©ë„를 맞춤화 시키는 ë°©ë²•ì„ ì•Œê²Œ ë 것ì´ë‹¤. Hibernate3ì—ì„œ, 페치 ë°©ë„를 ì„ íƒí•˜ëŠ” ë©”ì»¤ë‹ˆì¦˜ì€ ë‹¨ì¼ ê°’ 연관들과 ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ ë™ì¼í•˜ë‹¤."
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr "페치 ë°©ë„ë“¤ì„ íŠœë‹í•˜ê¸°"
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr "select 페ì¹(ë””í´íŠ¸)ì€ N+1 selects ë¬¸ì œì ë“¤ì— ë§¤ìš° 취약해서, 우리는 매핑 문서ì—ì„œ join 페ì¹ì„ 사용 가능하게 하기를 ì›í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr "매핑 문서 ë‚´ì— ì •ì˜ëœ <literal>fetch</literal> ë°©ë„는 다ìŒì— ì˜í–¥ì„ 준다:"
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr "<literal>get()</literal> ë˜ëŠ” <literal>load()</literal>를 통한 검색"
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr "ì—°ê´€ì´ ë„¤ë¹„ê²Œì´íŠ¸ë ë•Œ 함축ì 으로 ë°œìƒí•˜ëŠ” 검색"
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr "<literal>Criteria</literal> 질ì˜ë“¤"
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr "<literal>subselect</literal> 페ì¹ì´ 사용ë ê²½ìš°ì— HQL 질ì˜ë“¤"
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr "ë‹¹ì‹ ì´ ì‚¬ìš©í•˜ëŠ” íŽ˜ì¹ ë°©ë„ê°€ 무엇ì¸ê°€ì— ìƒê´€ì—†ì´, ì •ì˜ëœ 비-lazy 그래프가 메모리 ë‚´ë¡œ 로드ë˜ëŠ” ê²ƒì´ ë³´ìž¥ëœë‹¤. ì´ê²ƒì€ í•˜ë‚˜ì˜ íŠ¹ë³„í•œ HQL 질ì˜ë¥¼ ì‹¤í–‰ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë˜ëŠ” 몇몇 즉시ì ì¸ select들로 귀결ë 수 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr "대개, 우리는 페ì¹ì„ 맞춤화 ì‹œí‚¤ëŠ”ë° ë§¤í•‘ 문서를 사용하지 않는다. ëŒ€ì‹ ì—, 우리는 ë””í´íŠ¸ íŠ¹ì§•ì„ ìœ ì§€í•˜ê³ , HQLì—ì„œ <literal>left join fetch</literal>를 사용하여, íŠ¹ì • 트랜ìžì…˜ì— 대해 ê·¸ê²ƒì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다. ì´ê²ƒì€ outer joinì„ ì‚¬ìš©í•˜ì—¬ 첫 번째 selectì—ì„œ ì´ˆê¸°ì— ê·¸ ì—°ê´€ì„ eagerly 페치시킬 ê²ƒì„ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤. <literal>Criteria</literal> query APIì—ì„œ, 우리는 <literal>setFetchMode(FetchMode.JOIN)</literal>ì„ ì‚¬ìš©í•œë‹¤."
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>get()</literal> ë˜ëŠ” <literal>load()</literal>ì— ì˜í•´ ì‚¬ìš©ëœ íŽ˜ì¹ ë°©ë„를 변경시킬 수 있기를 ë‹¹ì‹ ì´ ì›í•œë‹¤ê³ ëŠë‚„ 경우, 단순하게 <literal>Criteria</literal> 질ì˜ë¥¼ 사용하ë¼. 예를 들면:"
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr "(ì´ê²ƒì€ 몇몇 ORM ì†”ë£¨ì…˜ë“¤ì´ \"페치 계íš\"ì´ë¼ê³ 부르는 ê²ƒì— ëŒ€í•œ Hibernateì˜ ë“±ê°€ë¬¼ì´ë‹¤.)"
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr "N+1 ê°œì˜ selectë“¤ì„ ê°€ì§„ ë¬¸ì œì ë“¤ì„ í”¼í•˜ëŠ” ì™„ì „ížˆ 다른 ë°©ë²•ì€ second-level ìºì‹œë¥¼ 사용하는 것ì´ë‹¤."
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr "Single-ended ì—°ê´€ 프ë½ì‹œ"
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr "ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ Lazy 페ì¹ì€ ì˜ì† ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ Hibernate ìžì‹ ì˜ êµ¬í˜„ì„ ì‚¬ìš©í•˜ì—¬ 구현ëœë‹¤. 하지만 다른 ë©”ì»¤ë‹ˆì¦˜ì€ single-ended 연관들ì—ì„œ lazy íŠ¹ì§•ì— í•„ìš”í•˜ë‹¤. ì—°ê´€ì˜ ëŒ€ìƒ ì—”í‹°í‹°ëŠ” 프ë½ì‹œ ë˜ì–´ì•¼ 한다. Hibernate는 (훌ë¥í•œ CGLIB ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ 통해) 런타임 ë°”ì´íŠ¸ì½”ë“œ ì¦ì§„ì„ ì‚¬ìš©í•˜ì—¬ ì˜ì† ê°ì²´ë“¤ì— 대한 lazy 초기화 프ë½ì‹œë“¤ì„ 구현한다."
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr "ë””í´íŠ¸ë¡œ, Hibernate3는 ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대해 (시작 ì‹œì—) 프ë½ì‹œë“¤ì„ ìƒì„±ì‹œí‚¤ê³ <literal>many-to-one</literal> 연관과 <literal>one-to-one</literal> ì—°ê´€ì— ëŒ€í•´ lazy 페ì¹ì„ ì´ìš© 가능하게 í•˜ëŠ”ë° ê·¸ê²ƒë“¤ì„ ì‚¬ìš©í•œë‹¤."
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr "매핑 파ì¼ì€ ê·¸ í´ëž˜ìŠ¤ì— 대한 프ë½ì‹œ ì¸í„°íŽ˜ì´ìŠ¤ë¡œì„œ ì‚¬ìš©í• , <literal>proxy</literal> ì†ì„±ì„ 가진, ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ ì„ ì–¸í• ìˆ˜ë„ ìžˆë‹¤. ë””í´íŠ¸ë¡œ Hibernate는 ê·¸ í´ëž˜ìŠ¤ì˜ 서브í´ëž˜ìŠ¤ë¥¼ 사용한다. <emphasis>프ë½ì‹œëœ í´ëž˜ìŠ¤ëŠ” ìµœì†Œí•œì˜ íŒ¨í‚¤ì§€ 가시성 (visibility)ì„ ê°€ì§„ ë””í´íŠ¸ ìƒì„±ìžë¥¼ 구현해야 í•¨ì„ ë…¸íŠ¸í•˜ë¼. 우리는 ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대해 ì´ ìƒì„±ìžë¥¼ 권장한다!</emphasis>"
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr "다형성 í´ëž˜ìŠ¤ë“¤ì— 대해 ì´ ì ‘ê·¼ë²•ì„ í™•ìž¥í• ë•Œ ì˜ì‹í•´ì•¼ 하는 몇몇 ë‚œì²˜í•¨ë“¤ì´ ì¡´ìž¬í•œë‹¤. 예를 들면."
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr "첫 번째로, 심지어 기본 ì¸ìŠ¤í„´ìŠ¤ê°€ <literal>DomesticCat</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ì¸ 경우조차ë„, <literal>Cat</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ê²°ì½” <literal>DomesticCat</literal>으로 타입ìºìŠ¤íŠ¸ê°€ 가능하지 ì•Šì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr "ë‘번째로, 프ë½ì‹œ <literal>==</literal>를 íŒŒê¸°í• ê°€ëŠ¥ì„±ì´ ìžˆë‹¤."
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr "하지만, ê·¸ 경우는 ë³´ì´ëŠ” ë§Œí¼ ê·¸ë ‡ê²Œ 나ì˜ì§€ëŠ” 않다. 심지어 우리가 ì´ì œ 다른 프ë½ì‹œ ê°ì²´ë“¤ì— 대한 ë‘ ê°œì˜ ì°¸ì¡°ë¥¼ 가질지ë¼ë„, 기본 ì¸ìŠ¤í„´ìŠ¤ëŠ” ì—¬ì „ížˆ ë™ì¼í•œ ê°ì²´ë“¤ì¼ 것ì´ë‹¤:"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr "세번째로, ë‹¹ì‹ ì€ <literal>final</literal> í´ëž˜ìŠ¤ ë˜ëŠ” ìž„ì˜ì˜ <literal>final</literal> ë©”ì†Œë“œë“¤ì„ ê°€ì§„ í´ëž˜ìŠ¤ì— 대해 CGLIB 프ë½ì‹œë¥¼ 사용하지 ì•Šì„ ìˆ˜ 있다."
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr "마지막으로, ë§Œì¼ ë‹¹ì‹ ì˜ ì˜ì† ê°ì²´ê°€ 초기화 ì‹œì— ì–´ë–¤ ë¦¬ì†ŒìŠ¤ë“¤ì„ í•„ìš”ë¡œ í• ê²½ìš°(예를 들어, initializer들 ë˜ëŠ” ë””í´íŠ¸ ìƒì„±ìž ë‚´ì—ì„œ), 그때 그들 ë¦¬ì†ŒìŠ¤ë“¤ì´ ë˜í•œ 프ë½ì‹œì— ì˜í•´ íšë“ë 것ì´ë‹¤. 프ë½ì‹œ í´ëž˜ìŠ¤ëŠ” ì˜ì† í´ëž˜ìŠ¤ì— 대한 ì‹¤ì œ 서브í´ëž˜ìŠ¤ì´ë‹¤."
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr "ì´ë“¤ ë¬¸ì œì ë“¤ì€ ëª¨ë‘ ìžë°”ì˜ ë‹¨ì¼ ìƒì† ëª¨í˜•ì˜ ê¸°ë³¸ì ì¸ ì œì•½ 때문ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì´ë“¤ ë¬¸ì œì ë“¤ì„ í”¼í•˜ê³ ìž ì›í• 경우 ë‹¹ì‹ ì˜ ì˜ì† í´ëž˜ìŠ¤ë“¤ì€ ê°ê° ê·¸ê²ƒì˜ ë¹„ì§€ë‹ˆìŠ¤ ë©”ì†Œë“œë“¤ì„ ì„ ì–¸í•˜ëŠ” ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현해야 한다. ë‹¹ì‹ ì€ ë§¤í•‘ íŒŒì¼ ì†ì— ì´ë“¤ ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì„ ì§€ì •í•´ì•¼ 한다. 예를 들면."
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr "여기서 <literal>CatImpl</literal>ì€ <literal>Cat</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ êµ¬í˜„í•˜ê³ <literal>DomesticCatImpl</literal>ì€ <literal>DomesticCat</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현한다. 그때 <literal>Cat</literal>ê³¼ <literal>DomesticCat</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 프ë½ì‹œë“¤ì€ <literal>load()</literal> ë˜ëŠ” <literal>iterate()</literal>ì— ì˜í•´ 반환ë 수 있다. (<literal>list()</literal>ê°€ 대개 프ë½ì‹œë“¤ì„ 반환하지 ì•ŠìŒì„ 노트하ë¼.)"
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr "ê´€ê³„ë“¤ì€ ë˜í•œ lazy 초기화 ëœë‹¤. ì´ê²ƒì€ ë‹¹ì‹ ì´ ìž„ì˜ì˜ 프로í¼í‹°ë“¤ì„ <literal>CatImpl</literal> íƒ€ìž…ì´ ì•„ë‹Œ <literal>Cat</literal> 타입으로 ì„ ì–¸í•´ì•¼ í•¨ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr "ì–´ë–¤ 오í¼ë ˆì´ì…˜ë“¤ì€ 프ë½ì‹œ 초기화를 필요로 하지 <emphasis>않는다</emphasis>"
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr "<literal>equals()</literal>, ë§Œì¼ ì˜ì† í´ëž˜ìŠ¤ê°€ <literal>equals()</literal>를 오버ë¼ì´ë“œ 시키지 않는 경우"
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr "<literal>hashCode()</literal>, ë§Œì¼ ì˜ì† í´ëž˜ìŠ¤ê°€<literal>hashCode()</literal>를 오버ë¼ì´ë“œ 시키지 않는 경우"
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr "ì‹ë³„ìž getter 메소드"
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr "Hibernate는 <literal>equals()</literal> ë˜ëŠ” <literal>hashCode()</literal>를 오버ë¼ì´ë“œ 시키는 ì˜ì† í´ëž˜ìŠ¤ë“¤ì„ ê²€ì¶œí• ê²ƒì´ë‹¤."
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr "ë””í´íŠ¸ <literal>lazy=\"proxy\"</literal> ëŒ€ì‹ ì— <literal>lazy=\"no-proxy\"</literal>를 ì„ íƒí•˜ì—¬, 우리는 타입ìºìŠ¤íŒ…ê³¼ ì—°ê´€ëœ ë¬¸ì œì ë“¤ì„ í”¼í• ìˆ˜ 있다. 하지만 우리는 빌드 ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ í• ê²ƒì´ê³ , ëª¨ë“ ì—°ì‚°ë“¤ì€ ì¦‰ê°ì ì¸ í”„ë½ì‹œ 초기화로 귀결ë 것ì´ë‹¤."
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr "ì½œë ‰ì…˜ë“¤ê³¼ 프ë½ì‹œë“¤ì„ 초기화 시키기"
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr "ë§Œì¼ ì´ˆê¸°í™” ë˜ì§€ ì•Šì€ ì½œë ‰ì…˜ì´ë‚˜ 프ë½ì‹œê°€ <literal>Session</literal> ì˜ì—ì˜ ì™¸ë¶€ì—ì„œ ì ‘ê·¼ë 경우ì—, 예를 들어 ì½œë ‰ì…˜ì„ ì†Œìœ í•˜ê±°ë‚˜ 프ë½ì‹œì— 대한 참조를 가진 엔티티가 detached ìƒíƒœì— ìžˆì„ ë•Œ, <literal>LazyInitializationException</literal>ì´ Hibernateì— ì˜í•´ ë˜ì ¸ì§ˆ 것ì´ë‹¤."
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr "때때로 우리는<literal>Session</literal>ì„ ë‹«ê¸° ì „ì— í”„ë½ì‹œ ë˜ëŠ” ì½œë ‰ì…˜ì´ ì´ˆê¸°í™” ë¨ì„ 확실히 í• í•„ìš”ê°€ 있다. ë¬¼ë¡ ìš°ë¦¬ëŠ” 예를 들어 <literal>cat.getSex()</literal> ë˜ëŠ” <literal>cat.getKittens().size()</literal>를 호출하여 í•ìƒ 초기화를 ê°•ì œì‹œí‚¬ 수 있다. 그러나 ê·¸ê²ƒì€ ì½”ë“œì˜ ë…ìžë“¤ì—게는 혼ë™ìŠ¤ëŸ½ê³ ì¼ë°˜ì ì¸ ì½”ë“œë¡œ 편ì˜ì ì´ì§€ 않다."
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr "static 메소드들 <literal>Hibernate.initialize()</literal>와 <literal>Hibernate.isInitialized()</literal>는 lazy 초기화 ëœ ì½œë ‰ì…˜ë“¤ì´ë‚˜ 프ë½ì‹œë“¤ì— 대해 작업하는 편리한 ë°©ë²•ì„ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— ì œê³µí•œë‹¤. <literal>Hibernate.initialize(cat)</literal>ì€ ê·¸ê²ƒì˜ <literal>Session</literal>ì´ ì—¬ì „ížˆ ì—´ë ¤ì ¸ 있는 í•œ 프ë½ì‹œ <literal>cat</literal>ì˜ ì´ˆê¸°í™”ë¥¼ ê°•ì œí• ê²ƒì´ë‹¤. <literal>Hibernate.initialize( cat.getKittens())</literal>는 kittensì˜ ì½œë ‰ì…˜ì— ëŒ€í•´ ìœ ì‚¬í•œ 효과를 갖는다."
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr "ë˜ ë‹¤ë¥¸ ì˜µì…˜ì€ ëª¨ë“ í•„ìš”í•œ ì½œë ‰ì…˜ë“¤ê³¼ 프ë½ì‹œë“¤ì´ 로드ë˜ê¸° ì „ê¹Œì§€ <literal>Session</literal>ì„ ì—´ë¦° 채로 ìœ ì§€í•˜ëŠ” 것ì´ë‹¤. 몇몇 어플리케ì´ì…˜ 아키í…처들, 특히 Hibernate를 사용하여 ë°ì´í„°ì— ì ‘ê·¼í•˜ëŠ” 코드, ê·¸ë¦¬ê³ ë‹¤ë¥¸ 어플리케ì´ì…˜ 계층들ì´ë‚˜ 다른 물리ì 프로세스들 ë‚´ì—ì„œ ê·¸ê²ƒì„ ì‚¬ìš©í•˜ëŠ” 코드ì—ì„œ, ê·¸ê²ƒì€ ì½œë ‰ì…˜ì´ ì´ˆê¸°í™” ë ë•Œ <literal>Session</literal>ì´ ì—´ë ¤ì ¸ 있ìŒì„ 확실히 하는 ë¬¸ì œì¼ ìˆ˜ 있다. ì´ ìŸì ì„ ë‹¤ë£¨ëŠ” ë‘ ê°€ì§€ 기본 ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr "웹 기반 어플리케ì´ì…˜ì—ì„œ, 서블릿 필터는 ë·° ë Œë”ë§ì´ 완료ë˜ëŠ”, ì‚¬ìš©ìž ìš”ì²ì˜ 바로 ëì—서만 <literal>Session</literal>ì„ ë‹«ëŠ”ë° ì‚¬ìš©ë 수 있다(<emphasis>Open Session in View</emphasis> 패턴). ë¬¼ë¡ ì´ê²ƒì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì¸í”„ë¼ìŠ¤íŠ¸ëŸì²˜ì˜ 예외ìƒí™© ì²˜ë¦¬ì˜ ì •ì •ì— ê´€í•œ 무거운 요구를 부과한다. ë·° ë Œë”ë§ ë™ì•ˆì— í•˜ë‚˜ì˜ ì˜ˆì™¸ìƒí™©ì´ ë°œìƒí• ë•Œì—ë„ ì‚¬ìš©ìžì—게 반환ë˜ê¸° ì „ì— <literal>Session</literal>ì´ ë‹«í˜€ì§€ê³ íŠ¸ëžœìžì…˜ì´ 종료ë˜ëŠ” ê²ƒì€ ì§€ê·¹ížˆ 중요하다. ì´ \"Open Session in View\" íŒ¨í„´ì— ê´€í•œ ì˜ˆì œë“¤ì€ Hibernate 위키를 ë³´ë¼."
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr "별ë„ì˜ ë¹„ì§€ë‹ˆìŠ¤ 티어를 가진 어플리케ì´ì…˜ì—ì„œ, 비지니스 ë¡œì§ì€ 반환 ì „ì— ì›¹ í‹°ì–´ì— í•„ìš”í•œ ëª¨ë“ ì½œë ‰ì…˜ë“¤ì„ \"준비\"해야 한다. ì´ê²ƒì€ 비지니스 í‹°ì–´ê°€ ëª¨ë“ ë°ì´í„°ë¥¼ ë¡œë“œì‹œí‚¤ê³ ì´ë¯¸ ì´ˆê¸°í™”ëœ ëª¨ë“ ë°ì´í„°ë¥¼ íŠ¹ì • ì“°ìž„ìƒˆì— í•„ìš”í•œ 프리ì í…Œì´ì…˜/웹 í‹°ì–´ë¡œ 반환해야 í•¨ì„ ì˜ë¯¸í•œë‹¤. 대개 어플리케ì´ì…˜ì€ 웹 í‹°ì–´ì— í•„ìš”í•˜ê²Œ ë ê°ê°ì˜ ì½œë ‰ì…˜ì— ëŒ€í•´ <literal>Hibernate.initialize()</literal>를 호출하거나(ì´ í˜¸ì¶œì€ ì„¸ì…˜ì´ ë‹«ížˆê¸° ì „ì— ë°œìƒí•´ì•¼ 한다) ë˜ëŠ” <literal>FETCH</literal> ì ˆì„ ê°–ê±°ë‚˜ ë˜ëŠ” <literal>Criteria</literal> ë‚´ì— <literal>FetchMode.JOIN</literal>ì„ ê°€ì§„ Hibernate 질ì˜ë¥¼ 사용하여 ì½œë ‰ì…˜ì„ ì—´ì‹¬ížˆ 검색한다. ì´ê²ƒì€ 대개 ë‹¹ì‹ ì´ <emphasis>Session Facade</emphasis> ëŒ€ì‹ <emphasis>Command</emphasis> íŒ¨í„´ì„ ì±„íƒí• ê²½ìš°ì— ë” ì‰½ë‹¤."
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ 초기화 ë˜ì§€ ì•Šì€ ì½œë ‰ì…˜ë“¤(ë˜ëŠ” 다른 프ë½ì‹œë“¤)ì— ì ‘ê·¼í•˜ê¸° ì „ì— <literal>merge()</literal> ë˜ëŠ” <literal>lock()</literal>으로 ì•žì„œ ë¡œë“œëœ ê°ì²´ë¥¼ 새로운 <literal>Session</literal>nì— ì²¨ë¶€í• ìˆ˜ë„ ìžˆë‹¤. 아니다. Hibernate는 ì´ê²ƒì„ ìžë™ì 으로 행하지 ì•Šê³ , 확실히 ìžë™ì 으로 행하지 <emphasis>ì•Šì„ ê²ƒì´ë‹¤</emphasis>. 왜ëƒí•˜ë©´ ê·¸ê²ƒì€ íŠ¹ë³„í•œ 목ì ì„ ìœ„í•œ 트랜ìžì…˜ ì˜ë¯¸ë¥¼ ë„ìž…í• ê²ƒì´ê¸° 때문ì´ë‹¤!"
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr "때때로 ë‹¹ì‹ ì€ ê±°ëŒ€í•œ ì½œë ‰ì…˜ì„ ì´ˆê¸°í™” 시키는 ê²ƒì„ ì›í•˜ì§€ 않지만, ì—¬ì „ížˆ (ê·¸ê²ƒì˜ ì‚¬ì´ì¦ˆì™€ ê°™ì€) ê·¸ê²ƒì— ëŒ€í•œ ì–´ë–¤ ì •ë³´ ë˜ëŠ” ë°ì´í„°ì˜ ë¶€ë¶„ì§‘í•©ì„ í•„ìš”ë¡œ 한다."
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr "ë‹¹ì‹ ì€ ê·¸ê²ƒì„ ì´ˆê¸°í™” 시키지 ì•Šê³ ì„œ ì½œë ‰ì…˜ì˜ ì‚¬ì´ì¦ˆë¥¼ ì–»ëŠ”ë° ì½œë ‰ì…˜ 필터를 ì‚¬ìš©í• ìˆ˜ 있다:"
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr "<literal>createFilter()</literal> 메소드는 ë˜í•œ ì „ì²´ ì½œë ‰ì…˜ì„ ì´ˆê¸°í™” 시킬 í•„ìš” ì—†ì´ ì½œë ‰ì…˜ì˜ ë¶€ë¶„ì§‘í•©ë“¤ì„ íš¨ìœ¨ì 으로 ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤:"
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr "batch íŽ˜ì¹ ì‚¬ìš©í•˜ê¸°"
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr "Hibernate는 배치 페ì¹ì„ 효율ì 으로 ì‚¬ìš©í• ìˆ˜ 있다. 즉 í•˜ë‚˜ì˜ í”„ë½ì‹œê°€ 액세스 ë ê²½ìš°ì— Hibernate는 몇몇 초기화 ë˜ì§€ ì•Šì€ í”„ë½ì‹œë“¤ì„ 로드시킬 수 있다(ë˜ëŠ” ì½œë ‰ì…˜ë“¤). batch 페ì¹ì€ lazy select íŽ˜ì¹ ë°©ë„ì— ëŒ€í•œ 최ì í™”ì´ë‹¤. ë‹¹ì‹ ì´ batch 페ì¹ì„ 튜ë‹ì‹œí‚¬ 수 있는 ë‘ ê°€ì§€ ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤: í´ëž˜ìŠ¤ ë ˆë²¨ì—ì„œ ê·¸ë¦¬ê³ ì½œë ‰ì…˜ ë ˆë²¨ì—ì„œ."
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr "í´ëž˜ìŠ¤ë“¤/ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ batch 페ì¹ì€ ì´í•´í•˜ê¸°ê°€ ë” ì‰½ë‹¤. ë‹¹ì‹ ì´ ì‹¤í–‰ ì‹œì— ë‹¤ìŒ ìƒí™©ì— ì²˜í•œë‹¤ê³ ìƒìƒí•˜ë¼: ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ <literal>Session</literal> ì†ì— ë¡œë“œëœ 25ê°œì˜ <literal>Cat</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ê°–ê³ ìžˆê³ , ê°ê°ì˜ <literal>Cat</literal>ì€ ê·¸ê²ƒì˜ <literal>ì†Œìœ ìž</literal> 즉, <literal>Person</literal>ì— ëŒ€í•œ 참조를 ê°–ê³ ìžˆë‹¤. <literal>Person</literal> í´ëž˜ìŠ¤ëŠ” 프ë½ì‹œ <literal>lazy=\"true\"</literal>로서 매핑ëœë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì´ì œ ëª¨ë“ catë“¤ì„ í†µí•´ ë°˜ë³µí•˜ê³ ê°ê°ì˜ catì— ëŒ€í•´ <literal>getOwner()</literal>를 í˜¸ì¶œí• ê²½ìš°, Hibernate는 프ë½ì‹œëœ ì†Œìœ ìžë“¤ì„ 검색하기 위해 25ê°œì˜ <literal>SELECT</literal> ë¬¸ìž¥ë“¤ì„ ë””í´íŠ¸ë¡œ 실행시킬 것ì´ë‹¤. ë‹¹ì‹ ì€ <literal>Person</literal> 매핑ì—ì„œ <literal>batch-size</literal>를 ì§€ì •í•¨ìœ¼ë¡œì¨ ì´ ë™ìž‘ì„ íŠœë‹ì‹œí‚¬ 수 있다:"
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr "Hibernate는 ì´ì œ 세 ê°œì˜ ì§ˆì˜ë“¤ ë§Œì„ ì‹¤í–‰ì‹œí‚¬ 것ì´ê³ , ê·¸ íŒ¨í„´ì€ 10,10, 5 ì´ë‹¤."
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ batch 페ì¹ì„ ì´ìš© 가능하게 í• ìˆ˜ë„ ìžˆë‹¤. 예를 들어, ë§Œì¼ ê°ê°ì˜ <literal>Person</literal>ì´ <literal>Cat</literal>ë“¤ì„ ê°€ì§„ lazy ì½œë ‰ì…˜ì„ ê°–ê³ , 10ê°œì˜ personë“¤ì´ <literal>Sesssion</literal> ë‚´ì— í˜„ìž¬ 로드ë˜ì–´ ìžˆì„ ê²½ìš°, ëª¨ë“ personë“¤ì— ëŒ€í•œ ë°˜ë³µì€ 10ê°œì˜ <literal>SELECT</literal>ë“¤ì„ ìƒì„±ì‹œí‚¬ 것ì´ê³ , <literal>getCats()</literal>ì— ëŒ€í•œ ë§¤ë²ˆì˜ í˜¸ì¶œì— ëŒ€í•´ í•˜ë‚˜ì˜ <literal>SELECT</literal>를 ìƒì„±ì‹œí‚¬ 것ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ <literal>Person</literal> 매핑ì—ì„œ <literal>cats</literal> ì½œë ‰ì…˜ì— ëŒ€í•´ batch 페ì¹ì„ 사용가능하게 í• ê²½ìš°, Hibernate는 ì½œë ‰ì…˜ë“¤ì„ ë¯¸ë¦¬-페치 시킬 수 있다:"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr "<literal>batch-size</literal> 8로서, Hibernate는 4ê°œì˜ SELECT들ì—ì„œ 3, 3, 3, 1 ê°œì˜ ì½œë ‰ì…˜ë“¤ì„ ë¡œë“œì‹œí‚¬ 것ì´ë‹¤. 다시 ê·¸ ì†ì„±ì˜ ê°’ì€ íŠ¹ì • <literal>Session</literal> ë‚´ì—ì„œ 초기화 ë˜ì§€ ì•Šì€ ì½œë ‰ì…˜ë“¤ì˜ ì˜ˆìƒë˜ëŠ” ê°œìˆ˜ì— ì˜ì¡´í•œë‹¤."
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ í•ëª©ë“¤ì˜ í¬ê°œì§„ 트리를 가질 경우, 예를 들어 ì „í˜•ì ì¸ bill-of-materials íŒ¨í„´ì¸ ê²½ìš°, (ë¹„ë¡ <emphasis>ë‚´í¬ëœ set</emphasis> ë˜ëŠ” <emphasis>ì‹¤ì²´í™”ëœ ê²½ë¡œ(materialized path)</emphasis>ê°€ 주로-ì½ê¸°-íŠ¸ë¦¬ë“¤ì— ëŒ€í•´ ë” ì¢‹ì€ ì˜µì…˜ì¼ ìˆ˜ 있ì„지ë¼ë„) ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ batch 페ì¹ì´ 특히 ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr "subselect íŽ˜ì¹ ì‚¬ìš©í•˜ê¸°"
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr "ë§Œì¼ í•œ ê°œì˜ lazy ì½œë ‰ì…˜ì´ë‚˜ ë‹¨ì¼ ê°’ 프ë½ì‹œê°€ 페치ë˜ì–´ì•¼ 한다면, Hibernate는 í•˜ë‚˜ì˜ subselect ë‚´ì—ì„œ ì›ëž˜ì˜ 질ì˜ë¥¼ 다시 실행하여 그것들 모ë‘를 로드시킨다. ì´ê²ƒì€ ì¡°ê°ë‚œ 로딩 ì—†ì´ batch 페ì¹ê³¼ ë™ì¼í•œ ë°©ì‹ìœ¼ë¡œ ë™ìž‘한다."
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr "lazy 프로í¼í‹° íŽ˜ì¹ ì‚¬ìš©í•˜ê¸°"
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr "Hibernate3ì€ ê°œë³„ì ì¸ í”„ë¡œí¼í‹°ë“¤ì— 대한 lazy 페ì¹ì„ 지ì›í•œë‹¤. ì´ ìµœì í™” ê¸°ìˆ ì€ ë˜í•œ <emphasis>fetch groups</emphasis> 으로 ì•Œë ¤ì ¸ 있다. ì´ê²ƒì´ 대개 마케팅 íŠ¹ì§•ìž„ì„ ë…¸íŠ¸í•˜ê¸¸ 바란다. 왜ëƒí•˜ë©´ ì‹¤ì œë¡œ í–‰ ì½ê¸°ë¥¼ 최ì í™” 시키는 ê²ƒì´ ì»¬ëŸ¼ ì½ê¸°ì— 대한 최ì í™” 보다 훨씬 ë” ì¤‘ìš”í•˜ê¸° 때문ì´ë‹¤. 하지만 리거시 í…Œì´ë¸”ë“¤ì´ ìˆ˜ë°± ê°œì˜ ì»¬ëŸ¼ë“¤ì„ ê°–ê³ ë°ì´í„° ëª¨í˜•ì´ ê°œì„ ë 수 ì—†ì„ ë•Œ, ì˜¤ì§ í´ëž˜ìŠ¤ì˜ 몇몇 프로í¼í‹°ë“¤ì„ 로드시키는 것 ë§Œì´ ìœ ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr "lazy 프로í¼í‹° ë¡œë”©ì„ ì´ìš©ê°€ëŠ¥í•˜ê²Œ í•˜ë ¤ë©´, ë‹¹ì‹ ì˜ íŠ¹ì • property ë§¤í•‘ë“¤ì— ëŒ€í•´ <literal>lazy</literal> ì†ì„±ì„ ì„¤ì •í•˜ë¼:"
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr "Lazy property ë¡œë”©ì€ ë¹Œë“œ ì‹œ ë°”ì´íŠ¸ì½”ë“œ ìˆ˜ë‹¨ì„ í•„ìš”ë¡œ 한다! ë§Œì¼ ë‹¹ì‹ ì˜ ì˜ì† í´ëž˜ìŠ¤ë“¤ì´ ê°œì„ ë˜ì§€ ì•Šì„ ê²½ìš°, Hibernate는 조용하게 lazy 프로í¼í‹° ì„¤ì •ë“¤ì„ ë¬´ì‹œí•˜ê³ ì¦‰ê°ì ì¸ íŽ˜ì¹ìœ¼ë¡œ í›„í‡´í• ê²ƒì´ë‹¤."
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr "bytecode 수단으로, ë‹¤ìŒ Ant 태스í¬ë¥¼ 사용하ë¼:"
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr "불필요한 컬럼 ì½ê¸°ë¥¼ 피하는 다른 (ë” ì¢‹ì€?) ë°©ë²•ì€ ì ì–´ë„ ì½ê¸° ì „ìš© 트랜ìžì…˜ì˜ ê²½ìš°ì— HQL ì§ˆì˜ ë˜ëŠ” Criteria 질ì˜ì˜ 투사(projection) íŠ¹ì§•ë“¤ì„ ì‚¬ìš©í•˜ëŠ” 것ì´ë‹¤. ì´ê²ƒì€ 빌드 ì‹œ ë°”ì´íŠ¸ì½”ë“œ ì²˜ë¦¬ì— ëŒ€í•œ í•„ìš”ì„±ì„ í”¼í•˜ê²Œ í•´ì£¼ê³ í™•ì‹¤ížˆ ì„ í˜¸ë˜ëŠ” í•´ê²°ì±…ì´ë‹¤."
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr "ë‹¹ì‹ ì€ HQLì—ì„œ <literal>fetch all properties</literal>를 사용하여 프로í¼í‹°ë“¤ì— 대한 통ìƒì˜ eager 페ì¹ì„ ê°•ì œì‹œí‚¬ 수 있다."
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr "ë‘번째 ë ˆë²¨ ìºì‹œ"
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr "Hibernate <literal>Session</literal>ì€ ì˜ì† ë°ì´í„°ì— 대한 트랜ìžì…˜ ë ˆë²¨ ìºì‹œì´ë‹¤. class-by-class와 collection-by-collection 기반 ìœ„ì— í´ëŸ¬ìŠ¤í„° ë˜ëŠ” JVM-ë ˆë²¨(<literal>SessionFactory</literal>-ë ˆë²¨) ìºì‹œë¥¼ 구성하는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. ë‹¹ì‹ ì€ í´ëŸ¬ìŠ¤í„°ë§ ëœ ìºì‹œ ì†ì— í”ŒëŸ¬ê·¸ì¸ í• ìˆ˜ë„ ìžˆë‹¤. 주ì˜í•˜ë¼. ìºì‹œë“¤ì€ (ë¹„ë¡ ê·¸ê²ƒë“¤ì´ ìºì‹œëœ ë°ì´í„°ë¥¼ ì •ê¸°ì 으로 만료ë˜ë„ë¡ êµ¬ì„±ë˜ì–´ 있ì„지ë¼ë„) ë˜ ë‹¤ë¥¸ 어플리케ì´ì…˜ì— ì˜í•´ ì˜ì† ì €ìž¥ì†Œì— ëŒ€í•´ 행해진 ë³€ê²½ë“¤ì„ ê²°ì½” 알지 못한다."
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr "ë””í´íŠ¸ë¡œ, Hibernate는 JVM-ë ˆë²¨ì˜ ìºì‹±ì— EHCache를 사용한다. (JCS 지ì›ì€ ì´ì œ 진부하게 ë˜ì—ˆê³ Hibernateì˜ ìž¥ëž˜ ë²„ì „ì—ì„œ ì œê±°ë 것ì´ë‹¤.) ë‹¹ì‹ ì€ <literal>hibernate.cache.provider_class</literal> 프로í¼í‹°ë¥¼ 사용하여 <literal>org.hibernate.cache.CacheProvider</literal>를 구현하는 í´ëž˜ìŠ¤ì˜ ì´ë¦„ì„ ì§€ì •í•¨ìœ¼ë¡œì¨ ë‹¤ë¥¸ êµ¬í˜„ì„ ì„ íƒí• ìˆ˜ë„ ìžˆë‹¤. You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2. !
ë‹¹ì‹ ì€ <literal>hibernate.cache.provider_class</literal> 프로í¼í‹°ë¥¼ 사용하여 <literal>org.hibernate.cache.CacheProvider</literal>를 구현하는 í´ëž˜ìŠ¤ì˜ ì´ë¦„ì„ ì§€ì •í•¨ìœ¼ë¡œì¨ ì–´ëŠ ìºì‹± êµ¬í˜„ì„ ì‚¬ìš©í• ê²ƒì¸ì§€ë¥¼ Hibernateì—게 ì•Œë ¤ì£¼ëŠ” ì˜µì…˜ì„ ê°–ëŠ”ë‹¤. Hibernate는 (ì•„ëž˜ì— ì—´ê±°ëœ) 오픈-소스 프로바ì´ë”ë“¤ì„ ê°€ì§„ ë§Žì€ ë¹Œë“œë˜ì–´ 있는 í†µí•©ë“¤ì„ ë²ˆë“¤ë¡œ ê°–ê³ ìžˆë‹¤; 추가ì 으로 ë‹¹ì‹ ì€ ìœ„ì—ì„œ ì–¸ê¸‰í–ˆë“¯ì´ ê·¸ê²ƒì— ë‹¹ì‹ ìžì‹ ì˜ ê²ƒì„ êµ¬í˜„í• ìˆ˜ ìžˆê³ ê·¸ê²ƒì— í”ŒëŸ¬ê·¸ 시킬 수 있다. 3.2 ì´ë²ˆ ë²„ì „ë“¤ì€ ë””í”ŒíŠ¸ ìºì‹œ 프로바ì´ë”로서 EhCache를 사용하ë„ë¡ ë””í¬ë¦ë¡œ 내장ë˜ì–´ 있ìŒì„ 노트하ë¼; ë²„ì „ 3.2ì˜ ê²½ìš°ì— ê·¸ê²ƒì€ ë”ì´ìƒ ë””í´íŠ¸ ë‚´ìž¥ì´ ì•„ë‹ˆë‹¤."
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr "ìºì‹œ 프로바ì´ë”들"
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr "<entry>ìºì‹œ</entry>"
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr "프로바ì´ë” í´ëž˜ìŠ¤"
+
+#: index.docbook:603
+msgid "Type"
+msgstr "<entry>타입</entry>"
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr "í´ëŸ¬ìŠ¤í„° ì•ˆì „"
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr "ì§ˆì˜ ìºì‹œ 지ì›"
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr "Hashtable (ì œí’ˆ ìš©ë„ë¡œ ê³ ì•ˆë˜ì–´ 있지 ì•ŠìŒ)"
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr "org.hibernate.cache.HashtableCacheProvider"
+
+#: index.docbook:612
+msgid "memory"
+msgstr "memory"
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr "<entry>yes</entry>"
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr "EHCache"
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr "org.hibernate.cache.EhCacheProvider"
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr "memory, disk"
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr "OSCache"
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr "org.hibernate.cache.OSCacheProvider"
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr "<entry>yes</entry>"
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr "SwarmCache"
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr "org.hibernate.cache.SwarmCacheProvider"
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr "clustered (ip multicast)"
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr "yes (clustered invalidation)"
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr "JBoss TreeCache"
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr "org.hibernate.cache.TreeCacheProvider"
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr "clustered (ip multicast), transactional"
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr "yes (replication)"
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr "yes (clock sync req.)"
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr "Cache 매핑들"
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr "í´ëž˜ìŠ¤ ë˜ëŠ” ì½œë ‰ì…˜ ë§¤í•‘ì˜ <literal><cache></literal> 요소는 ë‹¤ìŒ í˜•ì‹ì„ 갖는다:"
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr "<literal>usage</literal>(필수) ìºì‹± ë°©ë„를 ì§€ì •í•œë‹¤: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> ë˜ëŠ” <literal>read-only</literal>"
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr "<literal>region</literal> (옵션, ë””í´íŠ¸ëŠ” class ë˜ëŠ” ì½œë ‰ì…˜ role ì´ë¦„) second level ìºì‹œ ì˜ì—ì˜ ì´ë¦„ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr "<literal>include</literal> (옵션, ë””í´íŠ¸ëŠ” <literal>all</literal>) <literal>non-lazy</literal>는 <literal>lazy=\"true\"</literal>ë¡œ ë§¤í•‘ëœ ì—”í‹°í‹°ì˜ í”„ë¡œí¼í‹°ë“¤ì„ ì§€ì •í•˜ë©° ì†ì„±-ë ˆë²¨ lazy 페ì¹ì´ ì´ìš© ê°€ëŠ¥í• ë•Œ 키시ë 수 없다"
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr "다른 방법으로 (ì„ í˜¸ì 으로?), ë‹¹ì‹ ì€ <literal>hibernate.cfg.xml</literal> ë‚´ì— <literal><class-cache></literal>와 <literal><collection-cache></literal> ìš”ì†Œë“¤ì„ ì§€ì •í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr "<literal>usage</literal> ì†ì„±ì€ <emphasis> ìºì‹œ ë™ì‹œì„± ë°©ë„</emphasis>를 ì§€ì •í•œë‹¤."
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr "ë°©ë„: ì½ê¸° ì „ìš©"
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr "ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ì˜ì† í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ì½ì–´ë“¤ì¼ 필요가 있지만 ê²°ì½” ë³€ê²½í• í•„ìš”ê°€ ì—†ì„ ê²½ìš°ì— <literal>read-only</literal> ìºì‹œê°€ 사용ë 수 있다. ì´ê²ƒì€ 가장 간단한 최ìƒì˜ í¼í¬ë¨¼ìŠ¤ë¥¼ 위한 ë°©ë„ì´ë‹¤. ê·¸ê²ƒì€ í´ëŸ¬ìŠ¤í„° ë‚´ 사용ì—는 완벽하게 ì•ˆì „í•˜ë‹¤."
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr "ë°©ë„: ì½ê¸°/쓰기"
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr "어플리케ì´ì…˜ì´ ë°ì´í„°ë¥¼ ì—…ë°ì´íŠ¸ í• í•„ìš”ê°€ ìžˆì„ ê²½ìš°, <literal>read-write</literal> ìºì‹œê°€ ì ì ˆí•˜ë‹¤. ë§Œì¼ ì§ë ¬í™” 가능한(serializable) 트랜ìžì…˜ 격리 ë ˆë²¨ì´ í•„ìš”í•œ 경우ì—는 ì´ ìºì‹œ ë°©ë„ê°€ ê²°ì½” 사용ë˜ì§€ ë§ì•„야 한다. ë§Œì¼ ìºì‹œê°€ JTA 환경ì—ì„œ 사용ë 경우, ë‹¹ì‹ ì€ JTA <literal>TransactionManager</literal>를 얻는 ë°©ë„를 명명하는 <literal>hibernate.transaction.manager_lookup_class</literal> 프로í¼í‹°ë¥¼ ì§€ì •í•´ì•¼ 한다. 다른 환경들ì—ì„œ, ë‹¹ì‹ ì€<literal>Session.close()</literal> ë˜ëŠ” <literal>Session.disconnect()</literal>ê°€ 호출ë ë•Œ 트랜ìžì…˜ì´ 완료ë˜ëŠ” ê²ƒì„ í™•ì‹¤ížˆ 해야 한다. ë§Œì¼ ë‹¹ì‹ ì´ í´ëŸ¬ìŠ¤í„° ë‚´ì— ì´ ë°©ë„를 ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ ê¸°ë³¸ ìºì‹œ êµ¬í˜„ì´ ìž ê¸ˆì„ ì§€ì›í•˜ë„ë¡ í•˜ëŠ” ê²ƒì„ í™•ì‹¤ížˆ 해야 한다. 미리 만들어진 ìºì‹œ 프로바ì´ë”ë“¤ì€ ê·¸ë ‡ê²Œ 행하지 <emphasis>않는ë!
‹¤</emphasis>."
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr "ë°©ë„: 엄격하지 ì•Šì€ ì½ê¸°/쓰기"
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr "ë§Œì¼ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ì˜¤ì§ ë°ì´í„°ë¥¼ ìžì£¼ ì—…ë°ì´íŠ¸í• 필요가 ìžˆê³ (예를 들어, ë§Œì¼ ë‘ ê°œì˜ íŠ¸ëžœìžì…˜ë“¤ì´ ë™ì‹œì— ë™ì¼í•œ í•ëª©ì„ ì—…ë°ì´íŠ¸ í•˜ë ¤ê³ ì‹œë„하는 ì •ë§ ìžˆìŒì§í•˜ì§€ ì•Šì€ ê²½ìš°) ê·¸ë¦¬ê³ ì—„ê²©í•œ 트랜ìžì…˜ 격리가 필요하지 ì•Šì€ ê²½ìš°, <literal>nonstrict-read-write</literal> ìºì‹œê°€ ì ì ˆí• ìˆ˜ 있다. ë§Œì¼ ê·¸ ìºì‹œê°€ JTA 환경ì—ì„œ 사용ë 경우, ë‹¹ì‹ ì€ <literal>hibernate.transaction.manager_lookup_class</literal>를 ì§€ì •í•´ì•¼ 한다. 다른 환경들ì—ì„œ, ë‹¹ì‹ ì€ <literal>Session.close()</literal> ë˜ëŠ” <literal>Session.disconnect()</literal>ê°€ 호출ë ë•Œ 트랜ìžì…˜ì´ 완료ë˜ë„ë¡ í™•ì‹¤ížˆ 해야 한다."
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "ë°©ë„: transactional"
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr "<literal>transactional</literal> ìºì‹œ ë°©ë„는 JBoss TreeCache와 ê°™ì€ ì „ì²´ 트랜ìžì…˜ì ì¸ ìºì‹œ 프로바ì´ë”ë“¤ì— ëŒ€í•œ 지ì›ì„ ì œê³µí•œë‹¤. 그런 ìºì‹œëŠ” ì˜¤ì§ JTA 환경 ë‚´ì—ì„œ 사용ë 수 ìžˆê³ ë‹¹ì‹ ì€ <literal>hibernate.transaction.manager_lookup_class</literal>를 ì§€ì •í•´ì•¼ 한다."
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr "ìºì‹œ 프로바ì´ë”들 중 ì–´ëŠ ê²ƒë„ ëª¨ë“ ìºì‹œ ë™ì‹œì„± ë°©ë„ë“¤ì„ ì§€ì›í•˜ì§€ 않는다. ë‹¤ìŒ í…Œì´ë¸”ì€ ì–´ëŠ í”„ë¡œë°”ì´ë”ë“¤ì´ ì–´ëŠ ë™ì‹œì„± ë°©ë„들과 호환ë˜ëŠ”지를 보여준다."
+
+#: index.docbook:775
+msgid "read-only"
+msgstr "<entry>ìºì‹œ</entry>"
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr "ì½ê¸° ì „ìš©"
+
+#: index.docbook:777
+msgid "read-write"
+msgstr "엄격하지 ì•Šì€ ì½ê¸°-쓰기"
+
+#: index.docbook:778
+msgid "transactional"
+msgstr "ì½ê¸°-쓰기"
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr "<entry>예</entry>"
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr "ìºì‹œë“¤ì„ 관리하기"
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr "ë‹¹ì‹ ì´ ê°ì²´ë¥¼ <literal>save()</literal>, <literal>update()</literal> ë˜ëŠ” <literal>saveOrUpdate()</literal>ì— ì „ë‹¬í• ë•Œë§ˆë‹¤ ê·¸ë¦¬ê³ ë‹¹ì‹ ì´ <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> ë˜ëŠ” <literal>scroll()</literal>ì„ ì‚¬ìš©í•˜ì—¬ ê°ì²´ë¥¼ ê²€ìƒ‰í• ë•Œë§ˆë‹¤, ê·¸ ê°ì²´ëŠ” <literal>Session</literal>ì˜ ë‚´ë¶€ ìºì‹œì— 추가ëœë‹¤."
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr "<literal>flush()</literal>ê°€ 차후ì 으로 호출ë ë•Œ, ê·¸ ê°ì²´ì˜ ìƒíƒœëŠ” ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ê¸°í™” ë 것ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì´ ë™ê¸°í™”ê°€ ë°œìƒë˜ëŠ” ê²ƒì„ ì›í•˜ì§€ 않거나 ë§Œì¼ ë‹¹ì‹ ì´ ëŒ€ëŸ‰ì˜ ê°ì²´ë“¤ì„ 처리 중ì´ê³ 메모리를 효율ì 으로 ê´€ë¦¬í• í•„ìš”ê°€ ìžˆì„ ê²½ìš°, <literal>evict()</literal> 메소드는 first-level ìºì‹œë¡œë¶€í„° ê·¸ ê°ì²´ì™€ ê·¸ê²ƒì˜ ì½œë ‰ì…˜ë“¤ì„ ì œê±°í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다."
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr "<literal>Session</literal>ì€ ë˜í•œ ì¸ìŠ¤í„´ìŠ¤ê°€ 세션 ìºì‹œì— ì†í•˜ëŠ”지 여부를 ê²°ì •í•˜ëŠ”ë° <literal>contains()</literal> 메소드를 ì œê³µí•œë‹¤."
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr "세션 ìºì‹œë¡œë¶€í„° ëª¨ë“ ê°ì²´ë“¤ì„ ì™„ì „í•˜ê²Œ 퇴거시키기 위해, <literal>Session.clear()</literal>를 호출하ë¼."
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr "second-level ìºì‹œì˜ 경우, í•˜ë‚˜ì˜ ì¸ìŠ¤í„´ìŠ¤, ì „ì²´ í´ëž˜ìŠ¤, ì½œë ‰ì…˜ ì¸ìŠ¤í„´ìŠ¤ ë˜ëŠ” ì „ì²´ ì½œë ‰ì…˜ roleì˜ ìºì‹œëœ ìƒíƒœë¥¼ 퇴거시키는 <literal>SessionFactory</literal> ìƒì— ì •ì˜ëœ ë©”ì†Œë“œë“¤ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr "<literal>CacheMode</literal>는 íŠ¹ì • ì„¸ì…˜ì´ second-level ìºì‹œì™€ 어떻게 ìƒí˜¸ìž‘용하는지를 ì œì–´í•œë‹¤"
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr "<literal>CacheMode.NORMAL</literal> - second-level ìºì‹œë¡œë¶€í„° ì•„ì´í…œë“¤ì„ ì½ì–´ë“¤ì´ê³ second-level ìºì‹œë¡œ ì•„ì´í…œë“¤ì„ 기ë¡í•œë‹¤"
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr "<literal>CacheMode.GET</literal> - second-level ìºì‹œë¡œë¶€í„° ì•„ì´í…œë“¤ì„ ì½ì–´ë“¤ì´ì§€ë§Œ, ë°ì´í„°ë¥¼ ì—…ë°ì´íŠ¸í• 때를 ì œì™¸í•˜ë©´ second-level ìºì‹œë¡œ 기ë¡í•˜ì§€ 않는다"
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr "<literal>CacheMode.PUT</literal> - ì•„ì´í…œë“¤ì„ second-level ìºì‹œì— 기ë¡í•˜ì§€ë§Œ, second-level ìºì‹œë¡œë¶€í„° ì½ì–´ë“¤ì´ì§€ 않는다"
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr "<literal>CacheMode.REFRESH</literal> - ì•„ì´í…œë“¤ì„ second-level ìºì‹œë¡œê¸°ë¡í•˜ì§€ë§Œ, second-level ìºì‹œë¡œë¶€í„° ì½ì–´ë“¤ì´ì§€ ì•Šê³ , ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ì½ì–´ë“¤ì¸ ëª¨ë“ ì•„ì´í…œë“¤ì— 대한 second-level ìºì‹œì˜ ê°±ì‹ ì„ ê°•ì œì‹œì¼œ, <literal>hibernate.cache.use_minimal_puts</literal>ì˜ íš¨ê³¼ë¥¼ 무시한다"
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr "second-level ìºì‹œ ë˜ëŠ” ì§ˆì˜ ìºì‹œ ì˜ì—ì˜ ë‚´ìš©ë¬¼ì„ ë¸Œë¼ìš°ì§•í•˜ë ¤ë©´ <literal>Statistics</literal> API를 사용하ë¼:"
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr "ë‹¹ì‹ ì€ í†µê³„ë¥¼ ì´ìš© 가능하게 í•˜ê³ , ì„ íƒì 으로 Hibernateë¡œ 하여금 ìºì‹œ ì—”íŠ¸ë¦¬ë“¤ì„ ë³´ë‹¤ ì¸ê°„ì—게 ì´í•´ê°€ëŠ¥í•œ 형ì‹ìœ¼ë¡œ ìœ ì§€ì‹œí‚¤ë„ë¡ ê°•ì œì‹œí‚¤ëŠ” ê²ƒì´ í•„ìš”í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr "ì§ˆì˜ ìºì‹œ"
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr "ì§ˆì˜ ê²°ê³¼ ì…‹ë“¤ì´ ë˜í•œ ìºì‹œë ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ ë™ì¼í•œ 파ë¼ë¯¸í„°ë“¤ì„ ê°€ì§€ê³ ìžì£¼ 실행ë˜ëŠ” 질ì˜ë“¤ì—만 ìœ ìš©í•˜ë‹¤. ì§ˆì˜ ìºì‹œë¥¼ 사용하기 위해 ë‹¹ì‹ ì€ ë¨¼ì € ê·¸ê²ƒì„ ì´ìš© 가능하ë„ë¡ í•´ì•¼ 한다:"
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr "<![CDATA[hibernate.cache.use_query_cache true]]>"
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr "ì´ ì„¤ì •ì€ ë‘ ê°œì˜ ìƒˆë¡œìš´ ìºì‹œ ì˜ì—들 - ìºì‹œëœ ì§ˆì˜ ê²°ê³¼ ì…‹ë“¤ì„ ë³´ê´€í•˜ëŠ” 것 (<literal>org.hibernate.cache.StandardQueryCache</literal>), ì§ˆì˜ ê°€ëŠ¥í•œ í…Œì´ë¸”ë“¤ì— ëŒ€í•œ 가장 ìµœì‹ ì—…ë°ì´íŠ¸ë“¤ì— 대한 timestampë“¤ì„ ë³´ê´€í•˜ëŠ” 다른 것 (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>)-ì˜ ìƒì„±ì„ ê°•ì œí•œë‹¤ . ì§ˆì˜ ìºì‹œëŠ” ê²°ê³¼ ì…‹ ë‚´ì— ì‹¤ì œ ì—”í‹°í‹°ë“¤ì˜ ìƒíƒœë¥¼ ìºì‹œì‹œí‚¤ì§€ ì•ŠìŒì„ 노트하ë¼; ê·¸ê²ƒì€ ì˜¤ì§ ì‹ë³„ìž ê°’ë“¤ê³¼ ê°’ íƒ€ìž…ì˜ ê²°ê³¼ë“¤ ë§Œì„ ìºì‹œì‹œí‚¨ë‹¤. ë”°ë¼ì„œ ì§ˆì˜ ìºì‹œëŠ” í•ìƒ second-level ìºì‹œì™€ 함께 사용ë˜ì–´ì•¼ 한다."
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr "ëŒ€ë¶€ë¶„ì˜ ì§ˆì˜ë“¤ì€ ìºì‹±ìœ¼ë¡œë¶€í„° ì´ì ì´ ì—†ê¸°ì—, ë””í´íŠ¸ë¡œ 질ì˜ë“¤ì€ ìºì‹œë˜ì§€ 않는다. ìºì‹±ì„ ì´ìš© 가능하ë„ë¡ í•˜ë ¤ë©´, <literal>Query.setCacheable(true)</literal>를 호출하ë¼. ì´ í˜¸ì¶œì€ ê¸°ì¡´ ìºì‹œ ê²°ê³¼ë“¤ì„ ì°¾ëŠ” ê²ƒì„ ì§ˆì˜ì—게 허용해주거나 질ì˜ê°€ 실행ë ë•Œ ê·¸ê²ƒì˜ ê²°ê³¼ë“¤ì„ ìºì‹œì— 추가하는 ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ì§ˆì˜ ìºì‹œ 만료 ì •ì±…ë“¤ì— ëŒ€í•œ 세밀한 ì œì–´ë¥¼ 필요로 í• ê²½ìš°, ë‹¹ì‹ ì€ <literal>Query.setCacheRegion()</literal>ì„ í˜¸ì¶œí•¨ìœ¼ë¡œì¨ íŠ¹ë³„í•œ 질ì˜ì— 대해 명명ë˜ë‹ˆ ìºì‹œ ì˜ì—ì„ ì§€ì •í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr "ë§Œì¼ ì§ˆì˜ê°€ ê·¸ê²ƒì˜ ì§ˆì˜ ìºì‹œ ì˜ì—ì˜ ê°±ì‹ ì„ ê°•ì œì‹œì¼œì•¼ 하는 경우ì—, ë‹¹ì‹ ì€ <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>를 호출해야 한다. ì´ê²ƒì€ 기본 ë°ì´í„°ê°€ 별ë„ì˜ í”„ë¡œì„¸ìŠ¤ë¥¼ 통해 ì—…ë°ì´íŠ¸ë˜ì—ˆê³ (예를 들면, Hibernate를 통해 변경ë˜ì§€ ì•Šì•˜ê³ ) íŠ¹ì • ì§ˆì˜ ê²°ê³¼ ì…‹ë“¤ì„ ì„ íƒì 으로 ê°±ì‹ í•˜ëŠ” ê²ƒì„ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—게 허용해주는 경우들ì—ì„œ 특별히 ìœ ìš©í•˜ë‹¤. ì´ê²ƒì€ <literal>SessionFactory.evictQueries()</literal>를 통해 ì§ˆì˜ ìºì‹œ ì˜ì—ì„ í‡´ê±°ì‹œí‚¤ëŠ” 보다 효과ì ì¸ ëŒ€ì•ˆì´ë‹¤."
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr "ì½œë ‰ì…˜ í¼í¬ë¨¼ìŠ¤ ì´í•´í•˜ê¸°"
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr "우리는ì´ë¯¸ ì½œë ‰ì…˜ë“¤ì— ê´€í•´ ì–˜ê¸°í•˜ëŠ”ë° ê½¤ ë§Žì€ ì‹œê°„ì„ ì†Œìš”í–ˆë‹¤. ì´ ì ˆì—ì„œ 우리는 ì½œë ‰ì…˜ë“¤ì´ ì‹¤í–‰ ì‹œì— ì–´ë–»ê²Œ í–‰ìœ„í•˜ëŠ”ì§€ì— ê´€í•œ í•œ ìŒì˜ ìŸì ë“¤ì„ ì¡°ëª…í• ê²ƒì´ë‹¤."
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr "<title>분류</title>"
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr "Hibernate는 세 가지 기본ì ì¸ ì¢…ë¥˜ì˜ ì½œë ‰ì…˜ë“¤ì„ ì •ì˜í•œë‹¤:"
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr "ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr "one to many 연관들"
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr "many to many 연관들"
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr "ì´ ë¶„ë¥˜ëŠ” 여러 가지 í…Œì´ë¸”ê³¼ foreign key ê´€ê³„ë“¤ì„ êµ¬ë³„ì§“ì§€ë§Œ 우리가 관계형 ëª¨í˜•ì— ëŒ€í•´ ì•Œ 필요가 있는 ëª¨ë“ ê²ƒì„ ìš°ë¦¬ì—게 ë§í•´ì£¼ì§€ 않는다. 관계형 구조와 í¼í¬ë¨¼ìŠ¤ íŠ¹ì§•ë“¤ì„ ì™„ì „í•˜ê²Œ ì´í•´í•˜ê¸° 위해, 우리는 ë˜í•œ ì½œë ‰ì…˜ í–‰ë“¤ì„ ì—…ë°ì´íŠ¸í•˜ê±°ë‚˜ ì‚ì œí•˜ê¸° 위해 Hibernateì— ì˜í•´ 사용ë˜ëŠ” 프ë¼ì´ë¨¸ë¦¬ í‚¤ì˜ êµ¬ì¡°ë¥¼ ê²€í† í•´ì•¼ 한다. ì´ê²ƒì€ ë‹¤ìŒ ë¶„ë¥˜ë¥¼ ì œì•ˆí•œë‹¤:"
+
+#: index.docbook:994
+msgid "sets"
+msgstr "ì¸ë±ì‹± ëœ ì½œë ‰ì…˜ë“¤"
+
+#: index.docbook:997
+msgid "bags"
+msgstr "set들"
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr "bag들"
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr "ëª¨ë“ ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ë“¤(map들, list들, array들)ì€ <literal><key></literal>와 <literal><index></literal> 컬럼들로 ì´ë£¨ì–´ì§„ 프ë¼ì´ë¨¸ë¦¬ 키를 갖는다. ì´ ê²½ìš°ì— ì½œë ‰ì…˜ ì—…ë°ì´íŠ¸ë“¤ì€ 대개 극히 효율ì ì´ë‹¤ - Hibernateê°€ ê·¸ê²ƒì„ ì—…ë°ì´íŠ¸ë‚˜ ì‚ì œë¥¼ ì‹œë„í• ë•Œ 프ë¼ì´ë¨¸ë¦¬ 키는 효율ì 으로 ì¸ë±ì‹±ë 수 ìžˆê³ íŠ¹ì • í–‰ì€ íš¨ìœ¨ì 으로 위치지워질 수 있다."
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr "Setë“¤ì€ <literal><key></literal>와 요소 컬럼들로 êµ¬ì„±ëœ í”„ë¼ì´ë¨¸ë¦¬ 키를 갖는다. ì´ê²ƒì€ 몇몇 ìœ í˜•ì˜ ì½œë ‰ì…˜ 요소, 특히 composite 요소들 ë˜ëŠ” 대형 í…스트 ë˜ëŠ” ë°”ì´ë„ˆë¦¬ í•„ë“œë“¤ì— ëŒ€í•´ ëœ íš¨ìœ¨ì ì¼ ìˆ˜ 있다; ë°ì´í„°ë² ì´ìŠ¤ëŠ” 복잡한 프ë¼ì´ë¨¸ë¦¬ 키를 효율ì 으로 ì¸ë±ì‹±í•˜ëŠ” ê²ƒì´ ë¶ˆê°€ëŠ¥í• ìˆ˜ë„ ìžˆë‹¤. ë°˜ë©´ì— one to many ë˜ëŠ” many to many ì—°ê´€ë“¤ì˜ ê²½ìš°, 특히 합성 ì‹ë³„ìžë“¤ì˜ 경우ì—는 효율ì ì¼ ìˆ˜ ìžˆì„ ê²ƒ 같다.(부수-노트: ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì„ ìœ„í•œ <literal><set></literal>ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키를 ì‹¤ì œë¡œ ìƒì„±ì‹œí‚¤ê¸° 위해 <literal>SchemaExport</literal>를 ì›í•œë‹¤ë©´ ë‹¹ì‹ ì€ ëª¨ë“ ì»¬ëŸ¼ë“¤ì„ <literal>not-null=\"true\"</literal>ë¡œ ì„ ì–¸í•´ì•¼ 한다.)"
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr "<literal><idbag></literal> ë§¤í•‘ë“¤ì€ ëŒ€ìš© 키를 ì •ì˜í•˜ì—¬ì„œ, ê·¸ê²ƒë“¤ì€ í•ìƒ ì—…ë°ì´íŠ¸ì— 매우 효율ì ì´ë‹¤. 사실, ê·¸ê²ƒë“¤ì€ ìµœìƒì˜ 경우ì´ë‹¤."
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr "Bagë“¤ì€ ê°€ìž¥ ë‚˜ìœ ê²½ìš°ì´ë‹¤. 왜ëƒí•˜ë©´ í•˜ë‚˜ì˜ bagì€ ì¤‘ë³µ 요소 ê°’ë“¤ì„ í—ˆìš©í•˜ê³ ì¸ë±ìŠ¤ ì»¬ëŸ¼ì„ ê°–ì§€ 않기 때문ì—, 프ë¼ì´ë¨¸ë¦¬ 키가 ì •ì˜ë 수 없다. Hibernate는 중복 행들 사ì´ë¥¼ 구분 짓는 ë°©ë²•ì„ ê°–ê³ ìžˆì§€ 않다. Hibernate는 ê·¸ê²ƒì´ ë³€ê²½ë 때마다 (í•œ ê°œì˜ DELETEë¡œ) ì½œë ‰ì…˜ì„ ì™„ì „í•˜ê²Œ ì œê±°í•˜ê³ ë‹¤ì‹œ ìƒì„±ì‹œí‚´ìœ¼ë¡œì¨ ì´ ë¬¸ì œë¥¼ 해결한다. ì´ê²ƒì€ 매우 비효율ì ì´ë‹¤."
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr "one-to-many ì—°ê´€ì˜ ê²½ìš°, \"프ë¼ì´ë¨¸ë¦¬ 키\"는 ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì˜ ë¬¼ë¦¬ì ì¸ í”„ë¼ì´ë¨¸ë¦¬ 키가 ì•„ë‹ ìˆ˜ë„ ìžˆì§€ë§Œ- ì´ ê²½ìš°ì—ì„œë„ ìœ„ì˜ ë¶„ë¥˜ëŠ” ì—¬ì „ížˆ ìœ ìš©í•˜ë‹¤. (ê·¸ê²ƒì€ ì—¬ì „ížˆ Hibernateê°€ ì½œë ‰ì…˜ì˜ ê°œë³„ í–‰ë“¤ì„ ì–´ë–»ê²Œ \"위치지우는\"지를 ë°˜ì˜í•œë‹¤.)"
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr "List, map, idbag, setë“¤ì€ updateì— ê°€ìž¥ 효율ì ì¸ ì½œë ‰ì…˜ë“¤ì´ë‹¤"
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr "ìœ„ì˜ ë…¼ì˜ì—ì„œ, ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ë“¤ê³¼ (대개) setë“¤ì´ ìš”ì†Œë“¤ì„ ì¶”ê°€í•˜ê³ , ì œê±°í•˜ê³ ì—…ë°ì´íŠ¸í•¨ì— 있어 가장 효율ì ì¸ ì˜¤í¼ë ˆì´ì…˜ì„ 허용해준다."
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr "아마 ì¸ë±ì‹± ëœ ì½œë ‰ì…˜ë“¤ì´ many to many ì—°ê´€ë“¤ì„ ìœ„í•œ ë˜ëŠ” ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ì„ ìœ„í•œ setë“¤ì— ëŒ€í•´ ê°–ê³ ìžˆëŠ” 하나 ì´ìƒì˜ 장ì ë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal>Set</literal>ì˜ êµ¬ì¡° 때문ì—, Hibernate는 요소가 \"변경\"ë ë•Œ í–‰ì„ <literal>UPDATE</literal> 하지 않는다. <literal>Set</literal>ì— ëŒ€í•œ ë³€ê²½ë“¤ì€ í•ìƒ (개별 í–‰ë“¤ì— ëŒ€í•œ) <literal>INSERT</literal>와 <literal>DELETE</literal>를 통해 ë™ìž‘한다. 다시 ì´ ê²€í† ëŠ” one to many ì—°ê´€ë“¤ì— ì ìš©ë˜ì§€ 않는다."
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr "ë°°ì—´ë“¤ì´ lazy ë 수 ì—†ìŒì„ 관찰 í•œ 후ì—, 우리는 list들, map들, ê·¸ë¦¬ê³ idbagë“¤ì´ ë‹¨ë…ì´ ì•„ë‹Œ setë“¤ì„ ê°€ì§„ 가장 í¼í¬ë¨¼ìŠ¤ê°€ 좋ì€(non-inverse) ì½œë ‰ì…˜ íƒ€ìž…ë“¤ìž„ì„ ê²°ë¡ ì§€ì„ ê²ƒì´ë‹¤. Setë“¤ì€ Hibernate 어플리케ì´ì…˜ë“¤ì—ì„œ 가장 ê³µí†µëœ ì¢…ë¥˜ì˜ ì½œë ‰ì…˜ì´ ë 것ì´ë¼ 예ìƒëœë‹¤. ì´ê²ƒì€ \"set\" ì˜ë¯¸ê°€ 관계형 모형ì—ì„œ 가장 ê³ ìœ í•œ 것ì´ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr "하지만, 잘 ì„¤ê³„ëœ Hibernate ë„ë©”ì¸ ëª¨í˜•ë“¤ì—ì„œ, 우리는 대개 ëŒ€ë¶€ë¶„ì˜ ì½œë ‰ì…˜ë“¤ì´ ì‚¬ì‹¤ <literal>inverse=\"true\"</literal>를 가진 one-to-many ì—°ê´€ë“¤ìž„ì„ ë³´ê²Œ ëœë‹¤. ì´ë“¤ ì—°ê´€ë“¤ì˜ ê²½ìš°, ì—…ë°ì´íŠ¸ëŠ” ì—°ê´€ì˜ many-to-one ì—”ë“œì— ì˜í•´ 처리ë˜ê³ , ë”°ë¼ì„œ ì½œë ‰ì…˜ ì—…ë°ì´íŠ¸ í¼í¬ë¨¼ìŠ¤ì— 대한 ê²€í† ë“¤ì€ ë‹¨ìˆœížˆ ì ìš©ë˜ì§€ 않는다."
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr "Bag들과 listë“¤ì€ ê°€ìž¥ 효율ì ì¸ inverse ì½œë ‰ì…˜ë“¤ì´ë‹¤"
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr "단지 ë‹¹ì‹ ì´ ì˜ì›ížˆ bagë“¤ì„ ë²„ë¦¬ê¸° ì „ì—, bag들(ê³¼ ë˜í•œ list들)ì´ set들보다 훨씬 ë” ì„±ëŠ¥ì´ ì¢‹ì€ íŠ¹ë³„í•œ ê²½ìš°ë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal>inverse=\"true\"</literal>를 가진 ì½œë ‰ì…˜ë“¤(예를 들어, 표준 ì–‘ë°©í–¥ one-to-many 관계 특질)ì˜ ê²½ìš°, 우리는 bag ìš”ì†Œë“¤ì„ ì´ˆê¸°í™”(페치) 시킬 í•„ìš” ì—†ì´ bag ë˜ëŠ” listì— ìš”ì†Œë“¤ì„ ì¶”ê°€ì‹œí‚¬ 수 있다! ì´ê²ƒì€ <literal>Collection.add()</literal> ë˜ëŠ” <literal>Collection.addAll()</literal>ì´ (<literal>Set</literal>과는 달리) í•ìƒ bag ë˜ëŠ” <literal>List</literal>ì— ëŒ€í•´ true를 반환해야하기 때문ì´ë‹¤. ì´ê²ƒì€ 훨씬 ë‹¤ìŒ ê³µí†µì ì¸ ì½”ë“œë¥¼ ë” ë¹ ë¥´ê²Œ 만들 수 있다."
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr "ì› ìƒ· delete"
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr "종종 ì½œë ‰ì…˜ ìš”ì†Œë“¤ì„ í•˜ë‚˜ì”© ì‚ì œí•˜ëŠ” ê²ƒì€ ê·¹ížˆ 비효율ì ì¼ ìˆ˜ 있다! Hibernate는 ì™„ì „í•˜ê²Œ 바보가 아니어서, ê·¸ê²ƒì€ ìƒˆë¡œìš´ ê³µë°±ì˜ ì½œë ‰ì…˜ì˜ ê²½ìš°(예를 들어 ë‹¹ì‹ ì´ <literal>list.clear()</literal>를 í˜¸ì¶œí–ˆì„ ê²½ìš°)ì— ê·¸ê²ƒì„ í–‰í•˜ì§€ ì•Šì„ ê²ƒìž„ì„ ì•Œê³ ìžˆë‹¤. ì´ ê²½ìš°ì—, Hibernate는 í•˜ë‚˜ì˜ <literal>DELETE</literal> ëª…ë ¹ì„ ë‚´ë¦´ 것ì´ê³ 우리는 ëª¨ë‘ í–‰í–ˆë‹¤!"
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr "우리가 ê¸¸ì´ 20ì¸ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì— í•œ ê°œì˜ ìš”ì†Œë¥¼ ì¶”ê°€í•˜ê³ ê·¸ëŸ° ë‹¤ìŒ ë‘ ê°œì˜ ìš”ì†Œë“¤ì„ ì œê±°í•œë‹¤ê³ ê°€ì •í•˜ìž. Hibernate는 (ì½œë ‰ì…˜ì´ bagê°€ ì•„ë‹Œ í•œ) í•œ ê°œì˜ <literal>INSERT</literal> 문장과 ë‘ ê°œì˜ <literal>DELETE</literal> ë¬¸ìž¥ì„ ëª…ë ¹ 내릴 것ì´ë‹¤. ì´ê²ƒì€ 확실히 마ìŒì— ë“ ë‹¤."
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr "하지만, 우리가 ë‘ ê°œì˜ ìš”ì†Œë“¤ì„ ë‚¨ê²¨ë‘”ì±„ 18 ê°œì˜ ìš”ì†Œë“¤ì„ ì œê±°í•˜ê³ ë‚˜ì„œ 세 ê°œì˜ ìƒˆë¡œìš´ ìš”ì†Œë“¤ì„ ì¶”ê°€í•œë‹¤ê³ ê°€ì •í•˜ìž. ë‘ ê°€ì§€ 가능한 처리 ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr "하나씩 ì—´ ì—¬ëŸ ê°œì˜ í–‰ë“¤ì„ ì‚ì œí•œ 다ìŒì— 세 ê°œì˜ í–‰ë“¤ì„ ì‚½ìž…ì‹œí‚¨ë‹¤"
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr "(í•œ ê°œì˜ SQL <literal>DELETE</literal>ë¡œ)ì „ì²´ ì½œë ‰ì…˜ì„ ì‚ì œí•˜ê³ ëª¨ë“ ë‹¤ì„¯ê°œì˜ í˜„ìž¬ ìš”ì†Œë“¤ì„ (하나씩) insert 시킨다"
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr "Hibernate는 ë‘ ë²ˆì§¸ ì˜µì…˜ì´ ì•„ë§ˆ ì´ ê²½ìš°ì— ë” ë¹ ë¥´ë‹¤ëŠ” ì ì„ ì•Œ ë§Œí¼ ì¶©ë¶„ížˆ ì˜ë¦¬í•˜ì§€ 않다.(ê·¸ë¦¬ê³ Hibernateê°€ ê·¸ë ‡ê²Œ ì˜ë¦¬í•´ì§€ëŠ” ê²ƒì„ í¬ë§ 하는 ê²ƒì€ ê°€ëŠ¥í•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤; 그런 íŠ¹ì§•ì€ ë°ì´í„°ë² ì´ìŠ¤ 트리거들 ë“±ì„ í˜¼ë™ìŠ¤ëŸ½ê²Œ í• ìˆ˜ë„ ìžˆë‹¤.)"
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr "다행히, ë‹¹ì‹ ì€ ì›ëž˜ì˜ ì½œë ‰ì…˜ì„ íê¸°ì‹œí‚¤ê³ (예를 들어 참조 í•´ì œí•˜ê³ ) ëª¨ë“ í˜„ìž¬ ìš”ì†Œë“¤ì„ ê°€ì§„ ìƒˆë¡œì´ ì´ˆê¸°í™”ëœ ì½œë ‰ì…˜ì„ ë°˜í™˜í•¨ìœ¼ë¡œì¨ ì•„ë¬´ë•Œë“ ì§€ ì´ íŠ¹ì§•ì„ ê°•ì œì‹œí‚¬ 수 있다. ì´ê²ƒì€ ì‹œê°„ì´ íë¦„ì— ë”°ë¼ ë§¤ìš° ìœ ìš©í•˜ê³ ê°•ë ¥í•´ì§ˆ 수 있다."
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr "ë¬¼ë¡ ë‹¨ í•œë²ˆì˜ ì‚ì œ(one-shot-delete)는 <literal>inverse=\"true\"</literal>ë¡œ ë§¤í•‘ëœ ì½œë ‰ì…˜ë“¤ì— ì ìš©ë˜ì§€ 않는다."
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr "í¼í¬ë¨¼ìŠ¤ 모니터ë§í•˜ê¸°"
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr "최ì 화는 í¼í¬ë¨¼ìŠ¤ ê´€ë ¨ 숫ìžë“¤ì— 대한 모니터ë§ê³¼ ì ‘ê·¼ ì—†ì´ëŠ” ë§Žì´ ì‚¬ìš©ë˜ì§€ 않는다. Hibernate는 ê·¸ê²ƒì˜ ë‚´ë¶€ì ì¸ ì˜¤í¼ë ˆì´ì…˜ë“¤ì— 대한 ì „ì²´ ì˜ì—ì˜ íŠ¹ì§•ë“¤ì„ ì œê³µí•œë‹¤. Hibernateì—ì„œ Statistics는 <literal>SessionFactory</literal>ì— ëŒ€í•´ ì´ìš© 가능하다."
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr "SessionFactory ëª¨ë‹ˆí„°ë§ í•˜ê¸°"
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr "ë‹¹ì‹ ì€ ë‘ ê°€ì§€ 방법들로 <literal>SessionFactory</literal> metricsì— ì ‘ê·¼í• ìˆ˜ 있다. ë‹¹ì‹ ì˜ ì²« 번째 ì˜µì…˜ì€ <literal>sessionFactory.getStatistics()</literal>를 í˜¸ì¶œí•˜ê³ ë‹¹ì‹ ìŠ¤ìŠ¤ë¡œ <literal>Statistics</literal>를 ì½ê±°ë‚˜ ë””ìŠ¤í”Œë ˆì´ í•˜ëŠ” 것ì´ë‹¤."
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal>StatisticsService</literal> MBeanì„ ì´ìš© 가능하ë„ë¡ í• ê²½ìš° Hibernate는 ë˜í•œ metrics를 ë°œí‘œí•˜ëŠ”ë° JMX를 ì‚¬ìš©í• ìˆ˜ 있다. ë‹¹ì‹ ì€ ëª¨ë“ ë‹¹ì‹ ì˜<literal>SessionFactory</literal>ì— ëŒ€í•´ í•œ ê°œì˜ MBean ë˜ëŠ” íŒ©í† ë¦¬ 당 í•œ 개를 ì´ìš© 가능하게 í• ìˆ˜ 있다. ìµœì†Œí•œì˜ êµ¬ì„± ì˜ˆì œë“¤ì€ ë‹¤ìŒ ì½”ë“œë¥¼ ë³´ë¼:"
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr "TODO: ì´ê²ƒì€ ì˜ë¯¸ê°€ 없다: 첫번째 경우ì—, 우리는 ì§ì ‘ MBeanì„ ê²€ìƒ‰í•˜ê³ ì‚¬ìš©í•œë‹¤. ë‘ ë²ˆì§¸ ê²½ìš°ì— ìš°ë¦¬ëŠ” JNDI ì´ë¦„ì„ ì‚¬ìš©í•˜ê¸° ì „ì— ì„¸ì…˜ íŒ©í† ë¦¬ê°€ ë³´ê´€í•˜ê³ ìžˆëŠ” JNDI ì´ë¦„ì„ ë¶€ì—¬í•´ì•¼ 한다. <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>ì„ ì‚¬ìš©í•˜ë¼."
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr "ë‹¹ì‹ ì€ <literal>SessionFactory</literal>ì— ëŒ€í•œ 모니터ë§ì„ (비)활성화 시킬 수 있다"
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr "구성 ì‹œ : <literal>hibernate.generate_statistics</literal>, ë””í´íŠ¸ëŠ” <literal>false</literal>"
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr "실행 ì‹œ : <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> ë˜ëŠ” <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr "Statistics(통계량들)ì€ <literal>clear()</literal> 메소드를 사용하여 í”„ë¡œê·¸ëž˜ë° ë°©ì‹ìœ¼ë¡œ ìž¬ì„¤ì • ë 수 있다. ìš”ì•½ì€ <literal>logSummary()</literal> 메소드를 사용하여 logger(info ë ˆë²¨)ì—게 ì „ì†¡ë 수 있다."
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr "Metrics"
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr "Hibernate는 매우 기본ì ì¸ ê²ƒì—서부터 ì–´ë–¤ 시나리오들ì—만 ê´€ë ¨ëœ ì „ë¬¸ ì •ë³´ì— ì´ë¥´ëŠ” ë§Žì€ metrics를 ì œê³µí•œë‹¤. ëª¨ë“ ì´ìš© 가능한 ì¹´ìš´í„°ë“¤ì€ <literal>Statistics</literal> interface APIì—ì„œ 3ê°œì˜ ì¹´í…Œê³ ë¦¬ë¡œ 설명ë˜ì–´ 있다:"
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr "ì—´ë ¤ì§„ ì„¸ì…˜ë“¤ì˜ ê°œìˆ˜, ê²€ìƒ‰ëœ JDBC ì»¤ë„¥ì…˜ë“¤ì˜ ê°œìˆ˜ 등과 ê°™ì€ ì¼ë°˜ì ì¸ <literal>Session</literal> ì‚¬ìš©ì— ê´€ë ¨ëœ metrics."
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr "ì „ì²´ì 으로 엔티티들, ì½œë ‰ì…˜ë“¤, 질ì˜ë“¤, ê·¸ë¦¬ê³ ìºì‹œë“¤ì— ê´€ë ¨ëœ metrics(ì „ì— metricsë¡œ ì•Œë ¤ì ¸ 있ìŒ),"
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr "íŠ¹ì •í•œ 엔티티, ì½œë ‰ì…˜, ì§ˆì˜ ë˜ëŠ” ìºì‹œ ì˜ì—ì— ê´€ë ¨ëœ ìƒì„¸ metrics."
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr "예를 들어 ë‹¹ì‹ ì€ ì—”í‹°í‹°, ì½œë ‰ì…˜, 질ì˜ë“¤ì˜ ìºì‹œ 성공율 ë° ì‹¤íŒ¨ìœ¨, put(ì—ìž ì£¼, ìºì‹œ ì‹œë„, putt) 비율, ì½œë ‰ì…˜ë“¤ê³¼ 질ì˜ë“¤, ê·¸ë¦¬ê³ í‰ê· ì§ˆì˜ ìš”êµ¬ 시간 ë“±ì„ ì°¾ì„ ìˆ˜ 있다. 수 밀리초들가 ìžë°”ì—ì„œ ê·¼ì‚¬ì¹˜ì— ì¢…ì†ë¨ì„ ì˜ì‹í•˜ë¼. Hibernate는 JVM ì •ë°€ë„ì— ë¬¶ì—¬ ìžˆê³ , 몇몇 플랫í¼ë“¤ì—ì„œ ì´ê²ƒì€ 심지어 약 10초가 ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr "간단한 getterë“¤ì€ (예를 들어 íŠ¹ì • 엔티티, ì½œë ‰ì…˜, ìºì‹œ ì˜ì—ì— ë¬¶ì´ì§€ ì•Šì€) ì „ì— metricsì— ì ‘ê·¼í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤. ë‹¹ì‹ ì€ ê·¸ê²ƒ(íŠ¹ì • 엔티티, ì½œë ‰ì…˜, ë˜ëŠ” ìºì‹œ ì˜ì—)ì˜ ì´ë¦„ì„ í†µí•´, ê·¸ë¦¬ê³ ì§ˆì˜ë“¤ì— 대한 ê·¸ê²ƒì˜ HQL ë˜ëŠ” SQL í‘œí˜„ì„ í†µí•´ íŠ¹ì • 엔티티, ì½œë ‰ì…˜, ë˜ëŠ” ìºì‹œ ì˜ì—ì˜ metricsì— ì ‘ê·¼í• ìˆ˜ 있다. 추가 ì •ë³´ëŠ” <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, ê·¸ë¦¬ê³ <literal>QueryStatistics</literal>를 참조하ë¼. ë‹¤ìŒ ì½”ë“œëŠ” 간단한 ì˜ˆì œë¥¼ 보여준다:"
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+
+#: index.docbook:1161
+msgid "appended paragraph 1"
+msgstr "ëª¨ë“ ì—”í‹°í‹°ë“¤, ì½œë ‰ì…˜ë“¤, ì½œë ‰ì…˜ë“¤,질ì˜ë“¤ ê·¸ë¦¬ê³ ì˜ì— ìºì‹œë“¤ì— 대해 작업하기 위해, ë‹¹ì‹ ì€ ë‹¤ìŒ ë©”ì†Œë“œë“¤ë¡œì„œ 엔티티들, ì½œë ‰ì…˜ë“¤, 질ì˜ë“¤, ê·¸ë¦¬ê³ ì˜ì— ìºì‹œë“¤ì— 대한 ì´ë¦„ë“¤ì˜ ëª©ë¡ì„ ê²€ìƒ‰í• ìˆ˜ 있다: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, ê·¸ë¦¬ê³ <literal>getSecondLevelCacheRegionNames()</literal>."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,664 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤"
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr "ì˜ì† í´ëž˜ìŠ¤ë“¤ì€ 비지니스 ë¬¸ì œì˜ ì—”í‹°í‹°ë“¤(예를 들어 E-Commerce 어플리케ì´ì…˜ì—ì„œ ê³ ê°ì´ë‚˜ 주문)ì„ êµ¬í˜„í•˜ëŠ” 어플리케ì´ì…˜ ë‚´ì˜ í´ëž˜ìŠ¤ë“¤ì´ë‹¤. ì˜ì† í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ì˜ì† ìƒíƒœì— 있는 것으로 ì „í˜€ 간주ë˜ì§€ 않는다 - ëŒ€ì‹ ì— í•˜ë‚˜ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” transient ë˜ëŠ” detached ìƒíƒœì¼ 수 있다."
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr "Hibernate는 ì´ë“¤ í´ëž˜ìŠ¤ë“¤ì´ Plain Old Java Object (POJO) í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ìœ¼ë¡œì„œ ì•Œë ¤ì§„, 몇몇 간단한 ê·œì¹™ë“¤ì„ ë”°ë¥¼ ê²½ìš°ì— ê°€ìž¥ 잘 ë™ìž‘한다. 하지만 ì´ë“¤ 규칙들 중 ì–´ë–¤ ê²ƒë„ ì–´ë ¤ìš´ ì‚¬ì–‘ë“¤ì´ ì•„ë‹ˆë‹¤. ì§„ì • Hibernate3는 ë‹¹ì‹ ì˜ ì˜ì† ê°ì²´ë“¤ì˜ íŠ¹ì§•ì— ëŒ€í•´ 매우 ì ì€ ê²ƒì„ ê°€ì •í•œë‹¤. ë‹¹ì‹ ì€ ë‹¤ë¥¸ 방법들로 ë„ë©”ì¸ ëª¨í˜•ì„ í‘œí˜„í• ìˆ˜ 있다 : 예를 들어 <literal>Map</literal> ì¸ìŠ¤í„´ìŠ¤ì˜ íŠ¸ë¦¬ë“¤ì„ ì‚¬ìš©í•˜ê¸°."
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr "간단한 POJO ì˜ˆì œ"
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr "ëŒ€ë¶€ë¶„ì˜ ìžë°” 어플리케ì´ì…˜ë“¤ì€ ê³ ì–‘ì´ê³¼ë“¤ì„ 표현하는 ì˜ì† í´ëž˜ìŠ¤ë¥¼ 필요로 한다."
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr "ì¤€ìˆ˜í• ë„¤ ê°œì˜ ì£¼ìš” ê·œì¹™ë“¤ì´ ë‹¤ìŒì— 있다:"
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr "아규먼트 없는 ìƒì„±ìžë¥¼ 구현하ë¼"
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr "<literal>Cat</literal>ì€ ì•„ê·œë¨¼íŠ¸ 없는 ìƒì„±ìžë¥¼ 갖는다. ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ë“¤ì€ Hibernate는 <literal>Constructor.newInstance()</literal>를 사용하여 ê·¸ê²ƒë“¤ì„ ì´ˆê¸°í™” 시킬 수 있ë„ë¡ ë””í´íŠ¸ ìƒì„±ìž (publicì´ ì•„ë‹ ìˆ˜ 있다)를 ê°€ì ¸ì•¼ 한다. 우리는 Hibernate ë‚´ì—ì„œ 런타임 프ë½ì‹œ ìƒì„±ì„ 위한 ìµœì†Œí•œì˜ <emphasis>패키지</emphasis> 가시성(visibility)를 가진 ë””í´íŠ¸ ìƒì„±ìžë¥¼ 가질 ê²ƒì„ ê°•ë ¥í•˜ê²Œ 권장한다."
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr "identifier 프로í¼í‹°ë¥¼ ì œê³µí•˜ë¼(옵션)"
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr "<literal>Cat</literal>ì€ <literal>id</literal>ë¡œ ëª…ëª…ëœ í•˜ë‚˜ì˜ í”„ë¡œí¼í‹°ë¥¼ 갖는다. ì´ í”„ë¡œí¼í‹°ëŠ” ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키 컬럼으로 매핑ëœë‹¤. ì´ í”„ë¡œí¼í‹°ëŠ” ì–´ë–¤ 것으로 명명ë ìˆ˜ë„ ìžˆê³ , ê·¸ê²ƒì˜ íƒ€ìž…ì€ ìž„ì˜ì˜ ì›ì‹œ 타입, ì›ì‹œ \"wrapper\" 타입, <literal>java.lang.String</literal> ë˜ëŠ” <literal>java.util.Date</literal>ì¼ ìˆ˜ 있다. (ë§Œì¼ ë‹¹ì‹ ì˜ ë¦¬ê±°ì‹œ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ì´ composite í‚¤ë“¤ì„ ê°–ê³ ìžˆë‹¤ë©´, ë‹¹ì‹ ì€ ì´ë“¤ íƒ€ìž…ë“¤ì„ ê°€ì§„ ì‚¬ìš©ìž ì •ì˜ í´ëž˜ìŠ¤ë¥¼ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤ - ë‚˜ì¤‘ì— composite ì‹ë³„ìžë“¤ì— 대한 ì ˆì„ ë³´ë¼)"
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr "identifier 프로í¼í‹°ëŠ” 엄격하게 옵션ì´ë‹¤. ë‹¹ì‹ ì€ ê·¸ê²ƒì„ ìƒëžµí• ìˆ˜ë„ ìžˆê³ , Hibernateë¡œ 하여금 내부ì 으로 ê°ì²´ ì‹ë³„ìžë“¤ì„ 추ì 하ë„ë¡ í• ìˆ˜ 있다. 하지만 우리는 ì´ê²ƒì„ 권장하지 않는다."
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr "사실, ì–´ë–¤ ê¸°ëŠ¥ì€ identifier 프로í¼í‹°ë¥¼ ì„ ì–¸í•˜ëŠ” í´ëž˜ìŠ¤ë“¤ì— 대해서만 ì´ìš© 가능하다:"
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr "detached ê°ì²´ë“¤ì— 대한 Transitive reattachment(cascade update ë˜ëŠ” cascade merge) -"
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr "Session.saveOrUpdate()"
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr "Session.merge()"
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr "를 ë³´ë¼"
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr "우리는 ë‹¹ì‹ ì´ ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대해 ì¼ê´€ë˜ê²Œ ëª…ëª…ëœ identifier 프로í¼í‹°ë“¤ì„ ì„ ì–¸í• ê²ƒì„ ê¶Œìž¥í•œë‹¤. 게다가 우리는 ë‹¹ì‹ ì´ nullable 타입(예를 들어 non-primitive)ì„ ì‚¬ìš©í• ê²ƒì„ ê¶Œìž¥í•œë‹¤."
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr "finalì´ ì•„ë‹Œ í´ëž˜ìŠ¤ë“¤ì„ ì„ í˜¸í•˜ë¼(옵션)"
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr "Hibernateì˜ ì¤‘ì‹¬ 특징ì¸, 프ë½ì‹œ(<emphasis>proxies</emphasis>)ë“¤ì€ finalì´ ì•„ë‹Œ ì˜ì† í´ëž˜ìŠ¤ë“¤ ë˜ëŠ” ëª¨ë‘ public 메소드들로 ì„ ì–¸ëœ ì¸í„°íŽ˜ì´ìŠ¤ì˜ êµ¬í˜„ì¸ ì˜ì† í´ëž˜ìŠ¤ë“¤ì— ì˜ì¡´í•œë‹¤."
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr "ë‹¹ì‹ ì€ Hibernateë¡œ ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현하지 ì•Šì€ <literal>final</literal> í´ëž˜ìŠ¤ë“¤ì„ ì˜ì†í™” 시킬 수 있지만 ë‹¹ì‹ ì€ lazy ì—°ê´€ 페ì¹(lazy association fetching)ì— ëŒ€í•´ 프ë½ì‹œë“¤ì„ ì‚¬ìš©í• ìˆ˜ ì—†ì„ ê²ƒì´ë‹¤ -ê·¸ê²ƒì€ í¼í¬ë¨¼ìŠ¤ 튜ë‹ì„ 위한 ë‹¹ì‹ ì˜ ì˜µì…˜ë“¤ì„ ì œí•œì‹œí‚¬ 것ì´ë‹¤."
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ non-final í´ëž˜ìŠ¤ë“¤ ìƒì— <literal>public final</literal> ë©”ì†Œë“œë“¤ì„ ì„ ì–¸í•˜ëŠ” ê²ƒì„ í”¼í•´ì•¼ 한다. ë§Œì¼ ë‹¹ì‹ ì´ <literal>public final</literal> 메소드를 가진 í´ëž˜ìŠ¤ë¥¼ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ <literal>lazy=\"false\"</literal>를 ì„¤ì •í•¨ìœ¼ë¡œì¨ ëª…ì‹œì 으로 프ë½ì‹±ì„ 사용 불가능하ë„ë¡ í•´ì•¼ 한다."
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr "ì˜ì† í•„ë“œë“¤ì„ ìœ„í•œ accessor들과 mutatorë“¤ì„ ì„ ì–¸í•˜ë¼(옵션)"
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr "<literal>Cat</literal>ì€ ê·¸ê²ƒì˜ ëª¨ë“ ì˜ì† í•„ë“œë“¤ì— ëŒ€í•´ accessor ë©”ì†Œë“œë“¤ì„ ì„ ì–¸í•œë‹¤. ë§Žì€ ë‹¤ë¥¸ ORM ë„êµ¬ë“¤ì€ ì¸ìŠ¤í„´ìŠ¤ ë³€ìˆ˜ë“¤ì„ ì§ì ‘ ì˜ì†í™” 시킨다. 우리는 관계형 스키마와 í´ëž˜ìŠ¤ì˜ 내부ì ì¸ ë°ì´í„° 구조들 사ì´ì— ê°„ì ‘ì ì¸ ìˆ˜ë‹¨ì„ ì œê³µí•˜ëŠ” ê²ƒì´ ë” ì¢‹ë‹¤ê³ ë¯¿ê³ ìžˆë‹¤. ë””í´íŠ¸ë¡œ Hibernate는 ìžë°”빈즈 ìŠ¤íƒ€ì¼ í”„ë¡œí¼í‹°ë“¤ì„ ì˜ì†í™” ì‹œí‚¤ê³ , <literal>getFoo</literal>, <literal>isFoo</literal>와 <literal>setFoo</literal> 형ì‹ì˜ 메소드 ì´ë¦„ë“¤ì„ ì¸ì§€í•œë‹¤. ë‹¹ì‹ ì€ ì§„ì •ìœ¼ë¡œ íŠ¹ì • 프로í¼í‹°ì— 대한 ì§ì ‘ì ì¸ í•„ë“œ ì ‘ê·¼ìœ¼ë¡œ ì „í™˜í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr "프로í¼í‹°ë“¤ì€ public으로 ì„ ì–¸ë 필요가 <emphasis>없다</emphasis> - Hibernate는 ë””í´íŠ¸ë¡œ <literal>protected</literal> get/set ìŒ ë˜ëŠ” <literal>private</literal> get/set ìŒì„ 가진 프로í¼í‹°ë¥¼ ì˜ì†í™” 시킬 수 있다."
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr "ìƒì† 구현하기"
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr "서브í´ëž˜ìŠ¤ëŠ” ë˜í•œ 첫 번째 규칙들과 ë‘ ë²ˆì§¸ ê·œì¹™ë“¤ì„ ì£¼ì‹œí•´ì•¼ 한다. ê·¸ê²ƒì€ ìŠˆí¼í´ëž˜ìŠ¤ <literal>Cat</literal>으로부터 ê·¸ê²ƒì˜ identifier 프로í¼í‹°ë¥¼ ìƒì†ë°›ëŠ”다."
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr "<literal>equals()</literal>와 <literal>hashCode()</literal> 구현하기"
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¤ìŒì˜ 경우ë¼ë©´, ë‹¹ì‹ ì€ <literal>equals()</literal>와 <literal>hashCode()</literal> ë©”ì†Œë“œë“¤ì„ ì˜¤ë²„ë¼ì´ë“œ 시켜야 한다."
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr "í•˜ë‚˜ì˜ <literal>Set</literal> ì†ì— ì˜ì† í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ì§‘ì–´ë„£ê³ ìž ì˜ë„í•˜ê³ (many-valued ì—°ê´€ë“¤ì— ëŒ€í•´ 권장ë˜ëŠ” 방법) <emphasis>ê·¸ë¦¬ê³ </emphasis>"
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr "detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ reattachment(재첨부)를 ì‚¬ìš©í•˜ê³ ìž ì˜ë„하는"
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr "Hibernate는 íŠ¹ì • session 범위 ë‚´ì—서만 persistent identity(ë°ì´í„°ë² ì´ìŠ¤ í–‰)ê³¼ Java identityì˜ ê°™ìŒì„ 보장한다. ë”°ë¼ì„œ 우리가 다른 세션들ì—ì„œ ê²€ìƒ‰ëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 혼합시키ìžë§ˆìž, 우리가 <literal>Set</literal>ë“¤ì— ëŒ€í•´ ìœ ì˜ë¯¸í•˜ê²Œ ë§Œë“¤ê³ ìž ì›í• 경우, 우리는 <literal>equals()</literal>와 <literal>hashCode()</literal>를 구현해야 한다."
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr "가장 명백한 ë°©ë²•ì€ ë‘ ê°ì²´ë“¤ì˜ identifier ê°’ì„ ë¹„êµí•¨ìœ¼ë¡œì¨ <literal>equals()</literal>/<literal>hashCode()</literal>를 구현하는 것ì´ë‹¤. ë§Œì¼ ê·¸ ê°’ì´ ë™ì¼í•˜ë‹¤ë©´, 둘다 ë™ì¼í•œ ë°ì´í„°ë² ì´ìŠ¤ í–‰ì´ì–´ì•¼ í•˜ê³ , 그러므로 ê·¸ê²ƒë“¤ì€ ê°™ë‹¤(둘다 í•˜ë‚˜ì˜ <literal>Set</literal>ì— ì¶”ê°€ë˜ëŠ” 경우ì—, 우리는 <literal>Set</literal> ì†ì—ì„œ í•˜ë‚˜ì˜ ìš”ì†Œë§Œì„ ê°–ê²Œ ë 것ì´ë‹¤). 불행하게ë„, 우리는 ìƒì„±ë˜ëŠ” ì‹ë³„ìžë“¤ì„ 갖는 ê·¸ ì ‘ê·¼ë²•ì„ ì‚¬ìš©í• ìˆ˜ 없다! Hibernate는 ì˜¤ì§ ì‹ë³„ìž ê°’ë“¤ì„ ì˜ì†í™” ë˜ëŠ” ê°ì²´ë“¤ì— í• ë‹¹í• ê²ƒì´ê³ , ìƒˆë¡œì´ ìƒì„±ëœ ì¸ìŠ¤í„´ìŠ¤ëŠ” ìž„ì˜ì˜ identifier ê°’ì„ ê°–ì§€ ì•Šì„ ê²ƒì´ë‹¤! ë§Œì¼ ì¸ìŠ¤í„´ìŠ¤ê°€ ì €ìž¥ë˜ì§€ ì•Šê³ í˜„ìž¬ í•˜ë‚˜ì˜ <literal>Set</literal> ì†ì— ìžˆì„ ê²½ìš°ì—, ê·¸ê²ƒì„ ì €ìž¥í•˜ëŠ”ê²ƒì€ í•˜ë‚˜ì˜ ì‹ë³„ìž ê°’ì„ ê·¸ ê°ì²´ì—게 í• ë‹¹í• ê²ƒì´ë‹¤. ë§Œì¼ <literal>equals()</literal>와 <literal>ha!
shCode()</literal>ê°€ ê·¸ ì‹ë³„ìž ê°’ì— ê¸°ì´ˆí• ê²½ìš°, hash 코드는 <literal>Set</literal>ì˜ ê³„ì•½ì„ íŒŒê¸°í•˜ì—¬ 변경ë 것ì´ë‹¤. ì´ ë¬¸ì œì— ëŒ€í•œ ì „ì²´ ë…¼ì˜ì— 대해서는 Hibernate 웹 사ì´íŠ¸ë¥¼ ë³´ë¼. ì´ê²ƒì€ Hibernate ìŸì ì´ ì•„ë‹Œ, ê°ì²´ identity와 equalityì— ê´€í•œ 통ìƒì˜ ìžë°” ì˜ë¯¸ë¡ ìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr "우리는 <emphasis>Business key equality</emphasis>를 사용하여 <literal>equals()</literal>와 <literal>hashCode()</literal>를 êµ¬í˜„í• ê²ƒ 권장한다. Business key equality는 <literal>equals()</literal> 메소드가 비지니스 키, 즉 실세계ì—ì„œ ìš°ë¦¬ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì‹ë³„하게 ë 키(<emphasis>natural</emphasis> 후보 키)를 형성하는 프로í¼í‹°ë“¤ë§Œì„ 비êµí•œë‹¤ëŠ” ì ì„ ì˜ë¯¸í•œë‹¤ :"
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr "í•˜ë‚˜ì˜ ë¹„ì§€ë‹ˆìŠ¤ 키는 ë°ì´í„°ë² ì´ìŠ¤ 프ë¼ì´ë¨¸ë¦¬ 키 후보 ë§Œí¼ ê²¬ê³ í•˜ì§€ 않아야 한다(<xref linkend=\"transactions-basics-identity\"/>를 ë³´ë¼). 대개 ë³€ê²½í• ìˆ˜ 없는 프로í¼í‹° ë˜ëŠ” ìœ ì¼í•œ(unique) 프로í¼í‹°ëŠ” 대개 비지니스 í‚¤ì— ëŒ€í•œ ì¢‹ì€ í›„ë³´ë“¤ì´ë‹¤."
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr "ë™ì ì¸ ëª¨í˜•ë“¤"
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr "ë‹¤ìŒ íŠ¹ì§•ë“¤ì€ í˜„ìž¬ 실험ì 으로 ê³ ë ¤ë˜ê³ 있으며 장래ì—는 변경ë 수 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr "ì˜ì† ì—”í‹°í‹°ë“¤ì€ ë°˜ë“œì‹œ ì‹¤í–‰ì‹œì— POJO í´ëž˜ìŠ¤ë“¤ë¡œ ë˜ëŠ” ìžë°”빈즈 ê°ì²´ë“¤ë¡œ 표현ë˜ì–´ì•¼í• 필요는 없다. Hibernate는 ë˜í•œ (실행 ì‹œì— <literal>Map</literal>ë“¤ì„ ê°€ì§„ <literal>Map</literal>ë“¤ì„ ì‚¬ìš©í•˜ì—¬) ë™ì ì¸ ëª¨í˜•ë“¤ì„ ì§€ì›í•˜ê³ DOM4J 트리들로서 ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ í‘œí˜„ì„ ì§€ì›í•œë‹¤. ì´ ì ‘ê·¼ë²•ìœ¼ë¡œ, ë‹¹ì‹ ì€ ì˜ì† í´ëž˜ìŠ¤ë“¤ì„ 작성하지 ì•Šê³ , ì˜¤ì§ ë§¤í•‘ 파ì¼ë“¤ ë§Œì„ ìž‘ì„±í•œë‹¤."
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr "ë””í´íŠ¸ë¡œ, Hibernate는 í†µì‚°ì˜ POJO 모드로 ë™ìž‘한다. ë‹¹ì‹ ì€ <literal>default_entity_mode</literal> 구성 ì˜µì…˜ì„ ì‚¬ìš©í•˜ì—¬ 특별한 <literal>SessionFactory</literal>ì— ëŒ€í•´ ë””í´íŠ¸ 엔티티 표현 모드를 ì„¤ì •í• ìˆ˜ 있다 (<xref linkend=\"configuration-optional-properties\"/>ì„ ë³´ë¼)."
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr "ë‹¤ìŒ ì˜ˆì œë“¤ì€<literal>Map</literal>ë“¤ì„ ì‚¬ìš©í•˜ëŠ” í‘œí˜„ì„ ì„¤ëª…í•œë‹¤. ë¨¼ì € 매핑 파ì¼ì—ì„œ, <literal>entity-name</literal>ì€ í´ëž˜ìŠ¤ ì´ë¦„ ëŒ€ì‹ ì—(ë˜ëŠ” í´ëž˜ìŠ¤ ì´ë¦„ì— ë§ë¶™ì—¬) ì„ ì–¸ë˜ì–´ì•¼ 한다:"
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr "심지어 ë¹„ë¡ ì—°ê´€ë“¤ì´ ëŒ€ìƒ(target) í´ëž˜ìŠ¤ ì´ë¦„ë“¤ì„ ì‚¬ìš©í•˜ì—¬ ì„ ì–¸ë 지ë¼ë„, ì—°ê´€ë“¤ì˜ ëŒ€ìƒ(target) íƒ€ìž…ì€ ë˜í•œ POJOê°€ ì•„ë‹Œ ë™ì ì¸ ì—”í‹°í‹°ì¼ ìˆ˜ 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr "<literal>SessionFactory</literal>ì— ëŒ€í•œ ë””í´íŠ¸ 엔티티 모드를 <literal>dynamic-map</literal>으로 ì„¤ì •í•œ 후ì—, 우리는 <literal>Map</literal>ë“¤ì„ ê°€ì§„ <literal>Map</literal>ë“¤ì— ëŒ€í•´ 실행 ì‹œì— ìž‘ì—…í• ìˆ˜ 있다:"
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr "dynamic ë§¤í•‘ì˜ ìž¥ì ë“¤ì€ ì—”í‹°í‹° í´ëž˜ìŠ¤ êµ¬í˜„ì— ëŒ€í•œ í•„ìš” ì—†ì´ë„ í”„ë¡œí† íƒ€ì´í•‘ì„ ìœ„í•œ ë¹ ë¥¸ ì „í™˜ 시간ì´ë‹¤. 하지만 ë‹¹ì‹ ì€ ì»´íŒŒì¼ ì‹œ 타입 ì²´í‚¹ì„ ìžƒê³ ì‹¤í–‰ ì‹œì— ë§Žì€ ì˜ˆì™¸ìƒí™©ë“¤ì„ 다루게 ë 것ì´ë‹¤. Hibernate 매핑 ë•ë¶„ì—, ë‚˜ì¤‘ì— ê³ ìœ í•œ ë„ë©”ì¸ ëª¨í˜• êµ¬í˜„ì„ ìƒë‹¨ì— 추가하는 ê²ƒì´ í—ˆìš©ë˜ì–´ì„œ, ë°ì´í„°ë² ì´ìŠ¤ 스키마가 쉽게 ì •ê·œí™” ë˜ê³ 소리가 ìš¸ë ¤ í¼ì§ˆ 수 있다."
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr "엔티티 표현 ëª¨ë“œë“¤ì€ ë˜í•œ í•˜ë‚˜ì˜ ë‹¨ìœ„ <literal>Session</literal> ê¸°ì¤€ì— ëŒ€í•´ ì„¤ì •ë 수 있다:"
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr "<literal>EntityMode</literal>를 사용하는 <literal>getSession()</literal>ì— ëŒ€í•œ í˜¸ì¶œì€ <literal>SessionFactory</literal>ê°€ ì•„ë‹Œ, <literal>Session</literal> APIì— ëŒ€í•œ ê²ƒìž„ì„ ë…¸íŠ¸í•˜ê¸¸ 바란다. ê·¸ 방법으로, 새로운 <literal>Session</literal>ì€ ê¸°ë³¸ JDBC 커넥션, 트랜ìžì…˜, ê·¸ë¦¬ê³ ë‹¤ë¥¸ 컨í…스트 ì •ë³´ë¥¼ ê³µìœ í•œë‹¤. ì´ê²ƒì€ ë‹¹ì‹ ì´ ë‘ ë²ˆì§¸ <literal>Session</literal> ìƒì—ì„œ <literal>flush()</literal>와 <literal>close()</literal>를 호출하지 ë§ì•„야 í•˜ê³ , ë˜í•œ 트랜ìžì…˜ ë° ì»¤ë„¥ì…˜ 핸들ë§ì„ ì£¼ëœ ìž‘ì—… 단위ì—게 맡긴다는 ì ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr "XML 표현 ê°€ìš©ì„±ë“¤ì— ëŒ€í•œ 추가 ì •ë³´ëŠ” <xref linkend=\"xml\"/>ì—ì„œ ì°¾ì„ ìˆ˜ 있다."
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr "Tuplizer들"
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr "<literal>org.hibernate.tuple.Tuplizer</literal>, ê·¸ë¦¬ê³ ê·¸ê²ƒì˜ ì„œë¸Œ-ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì€ ë°ì´í„°ì˜ ì¡°ê°ì— 대한 특별한 í‘œí˜„ì˜ <literal>org.hibernate.EntityMode</literal>ê°€ 주어지면 ê·¸ í‘œí˜„ì„ ê´€ë¦¬í•˜ëŠ” ì±…ìž„ì´ ìžˆë‹¤. ë§Œì¼ ì£¼ì–´ì§„ ë°ì´í„° ì¡°ê°ì´ í•˜ë‚˜ì˜ ë°ì´í„° 구조로 간주ë 경우, 그때 í•˜ë‚˜ì˜ tuplizer는 그런 ë°ì´í„° 구조를 ìƒì„±ì‹œí‚¤ëŠ” 방법과 그런 ë°ì´í„° 구조로부터 ê°’ë“¤ì„ ì¶”ì¶œì‹œí‚¤ëŠ” 방법 ê·¸ë¦¬ê³ ê·¸ëŸ° ë°ì´í„°êµ¬ì¡° ì†ìœ¼ë¡œ ê°’ë“¤ì„ ì‚½ìž…ì‹œí‚¤ëŠ” ë°©ë²•ì„ ì•Œê³ ìžˆëŠ” 것ì´ë‹¤. 예를 들어, POJO 엔티티 ëª¨ë“œì˜ ê²½ìš°, 대ì‘하는 tuplizer는 ê·¸ê²ƒì˜ ìƒì„±ìžë¥¼ 통해 POJO를 ìƒì„±ì‹œí‚¤ëŠ” 방법, ê·¸ë¦¬ê³ ì •ì˜ëœ 프로í¼í‹° ì ‘ê·¼ìžë“¤ì„ 사용하여 POJO 프로í¼í‹°ë“¤ì— ì ‘ê·¼í•˜ëŠ” ë°©ë²•ì„ ì•ˆë‹¤. <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> ì¸í„°íŽ˜ì´ìŠ¤ì™€ <literal>org.hibernate.tuple.component.ComponentTuplizer</!
literal> ì¸í„°íŽ˜ì´ìŠ¤ì— ì˜í•´ 표현ë˜ëŠ” ë‘ ê°€ì§€ ê³ ê¸‰ ìœ í˜•ì˜ Tuplizerë“¤ì´ ì¡´ìž¬í•œë‹¤. <literal>EntityTuplizer</literal>ë“¤ì€ ì—”í‹°í‹°ë“¤ì— ê´€í•´ì„œëŠ” ìœ„ì— ì–¸ê¸‰ëœ ê³„ì•½ë“¤ì„ ë§¤í•‘í• ì±…ìž„ì´ ìžˆëŠ” 반면ì—, <literal>ComponentTuplizer</literal>ë“¤ì€ ì»´í¬ë„ŒíŠ¸ë“¤ì— ëŒ€í•´ì„œë„ ë™ì¼í•œ ê²ƒì„ í–‰í•œë‹¤."
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr "사용ìžë“¤ì€ ë˜í•œ 그들 ìžì‹ ì˜ tuplizerë“¤ì„ í”ŒëŸ¬ê·¸ 시킬 수 있다. 아마 ë‹¹ì‹ ì€ dynamic-map entity-mode ë™ì•ˆì— 사용ë˜ëŠ” <literal>java.util.HashMap</literal> ëŒ€ì‹ ì— í•˜ë‚˜ì˜ <literal>java.util.Map</literal> êµ¬í˜„ì„ í•„ìš”ë¡œ 한다; ë˜ëŠ” 아마 ë‹¹ì‹ ì€ ë””í´íŠ¸ë¡œ 사용ë˜ëŠ” ë°©ë„ ë³´ë‹¤ëŠ” í•˜ë‚˜ì˜ ë‹¤ë¥¸ 다른 프ë¦ì‹œ 산출 ë°©ë„를 필요로 한다. 둘다 í•˜ë‚˜ì˜ ë§žì¶¤í˜• tuplizer를 ì •ì˜í•¨ìœ¼ë¡œì¨ 성취ë 것ì´ë‹¤. Tuplizer들 ì •ì˜ë“¤ì€ ê·¸ê²ƒë“¤ì´ ê´€ë¦¬í• ìˆ˜ë‹¨ì¸ ì—”í‹°í‹° 매핑 ë˜ëŠ” ì»´í¬ë„ŒíŠ¸ ë§¤í•‘ì— ì²¨ë¶€ëœë‹¤. ìš°ë¦¬ì˜ ê³ ê° ì—”í‹°í‹°ì— ëŒ€í•œ ì˜ˆì œë¡œ ë˜ëŒì•„가면:"
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:293
+msgid "appended paragraph 1"
+msgstr "TODO: property 패키지와 proxy 패키지 ë‚´ì— user-extension í”„ë ˆìž„ì›ì„ 문서화 í• ê²ƒ."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr "<title>머리ë§</title>"
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "ê°ì²´ 지향 소프트웨어와 관계형 ë°ì´í„°ë² ì´ìŠ¤ë¡œ 작업하는 ê²ƒì€ ì˜¤ëŠ˜ë‚ ì˜ ì—”í„°í”„ë¼ì´ì¦ˆ 환경들ì—ì„œ ì„±ê°€ì‹œê³ ì‹œê°„ì´ ì†Œë¹„ë 수 있다. Hibernate는 ìžë°” í™˜ê²½ë“¤ì„ ìœ„í•œ ê°ì²´/관계형 매핑 ë„구ì´ë‹¤. object/relational mapping(ORM) 용어는 ê°ì²´ 모형으로부터 SQL-ê¸°ë°˜ì˜ ìŠ¤í‚¤ë§ˆë¥¼ 가진 관계형 ë°ì´í„° ëª¨í˜•ìœ¼ë¡œì˜ ë°ì´í„° í‘œìƒì„ 매핑하는 ê¸°ìˆ ì„ ì–¸ê¸‰í•œë‹¤."
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Hibernate는 ìžë°” í´ëž˜ìŠ¤ë“¤ë¡œë¶€í„° ë°ì´í„°ë² ì´ìŠ¤ë¡œì˜ 매핑(ê·¸ë¦¬ê³ ìžë°” ë°ì´í„° 타입들로부터 SQL ë°ì´í„° íƒ€ìž…ë“¤ë¡œì˜ ë§¤í•‘)ì„ ì²˜ë¦¬í• ë¿ë§Œ 아니ë¼, ë˜í•œ ë°ì´í„° 질ì˜ì™€ 검색 편ì˜ë“¤ì„ ì œê³µí•˜ë©°, SQLê³¼ JDBCë¡œ 수작업 ë°ì´í„° 핸들ë§ì— 소요ë˜ëŠ” 개발 ì‹œê°„ì„ í˜„ì €í•˜ê²Œ 단축시켜줄 수 있다."
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "Hibernateì˜ ëª©ì ì€ ê³µí†µëœ ë°ì´í„° ì˜ì†í™” ê´€ë ¨ í”„ë¡œê·¸ëž˜ë° ìž‘ì—…ë“¤ì˜ 95%를 ëœì–´ì£¼ëŠ” 것ì´ë‹¤. Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ 비지니스 ë¡œì§ì„ êµ¬í˜„í•˜ëŠ”ë° ë‚´ìž¥ í”„ë¡œì‹œì €ë“¤ì„ ì „ìš©ìœ¼ë¡œ 사용하는 ë°ì´í„° 중심ì 어플리케ì´ì…˜ì— 대한 최ìƒì˜ ì†”ë£¨ì…˜ì´ ì•„ë‹ ìˆ˜ë„ ìžˆì§€ë§Œ, ê·¸ê²ƒì€ ìžë°” 기반 미들-í‹°ì–´ì—ì„œ ê°ì²´ 지향 ë„ë©”ì¸ ëª¨í˜•ë“¤ê³¼ 비지니스 ë¡œì§ì— 가장 ìœ ìš©í•˜ë‹¤. 하지만 Hibernate는 ë²¤ë” ì§€ì •ì ì¸ SQL 코드를 ì œê±°í•˜ê±°ë‚˜ 캡ìŠí™” 시키는 ë‹¹ì‹ ì„ í™•ì‹¤ížˆ ë„와줄 수 ìžˆê³ í…Œì´ë¸” 형ì‹ì˜ 표현으로부터 ê°ì²´ë“¤ì˜ 그래프로 ê²°ê³¼ ì…‹ì„ ë³€í™˜í•˜ëŠ” ê³µí†µëœ íƒœìŠ¤í¬ë¥¼ ë„와줄 것ì´ë‹¤."
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ Hibernate와 Object/Relational 매핑 ë˜ëŠ” 심지어 ìžë°”ì— ì´ˆì‹¬ìžë¼ë©´, ë‹¤ìŒ ë‹¨ê³„ë“¤ì„ ë”°ë¥´ê¸° 바란다:"
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "ë” ë§Žì€ ë‹¨ê³„ì ì¸ ì‚¬ìš© ì„¤ëª…ì„œë“¤ì„ ê°€ì§„ ë” ê¸´ íŠœí† ë¦¬ì–¼ì€ <xref linkend=\"tutorial\"/> ì„ ì½ì–´ë¼. íŠœí† ë¦¬ì–¼ì„ ìœ„í•œ 소스 코드는 <literal>doc/reference/tutorial/</literal> ë””ë ‰í† ë¦¬ì— í¬í•¨ë˜ì–´ 있다."
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr "Hibernateê°€ 사용ë 수 있는 í™˜ê²½ì„ ì´í•´ë ¤ë©´ <xref linkend=\"architecture\"/> 를 ì½ì–´ë¼."
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "Hibernate ë°°í¬ë³¸ ë‚´ì˜ <literal>eg/</literal> ë””ë ‰í† ë¦¬ë¥¼ 살펴 ë³´ë¼. ì´ ë””ë ‰í† ë¦¬ëŠ” 간단한 ìŠ¤íƒ ë“œì–¼ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ í¬í•¨í•˜ê³ 있다. ë‹¹ì‹ ì˜ JDBC ë“œë¼ì´ë²„를 <literal>lib/</literal> ë””ë ‰í† ë¦¬ì— ë³µì‚¬í•˜ê³ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ì— 맞는 ì •í™•í•œ ê°’ì„ ì§€ì •í•˜ì—¬ <literal>etc/hibernate.properties</literal> 를 편집하ë¼. 배보본 ë””ë ‰í† ë¦¬ì—ì„œ ëª…ë ¹ ë¼ì¸ 프롬프트ì—ì„œ (Ant를 사용하여) <literal>ant eg</literal> 를 타ì´í•‘ 하거나 , Windows 하ì—ì„œ <literal>build eg</literal> 를 타ì´í”„ 하ë¼."
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "ë‹¹ì‹ ì˜ ì£¼ëœ ì •ë³´ì˜ ì†ŒìŠ¤ë¡œì„œ ì´ ì°¸ì¡° 문서를 사용하ë¼. ë§Œì¼ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì„¤ê³„ì— ëŒ€í•´ ë” ë§Žì€ ë„ì›€ì„ í•„ìš”ë¡œ 하거나 ë‹¹ì‹ ì´ ë‹¨ê³„ì ì¸ íŠœí† ë¦¬ì–¼ì„ ì„ í˜¸í•œë‹¤ë©´ <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2)ì„ ì½ëŠ” ê²ƒì„ ê³ ë ¤í•˜ë¼.ë˜í•œ http://caveatemptor.hibernate.orgì— ë°©ë¬¸í•˜ì—¬ Java Persistence with Hibernateìš© ì˜ˆì œ 어플리케ì´ì…˜ì„ 다운로드 하ë¼."
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr "FAQë“¤ì€ Hibernate 웹 사ì´íŠ¸ ìƒì— 답변ë˜ì–´ 있다."
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr "ì œ 3ì˜ ë°ëª¨ë“¤, ì˜ˆì œë“¤, ê·¸ë¦¬ê³ íŠœí† ë¦¬ì–¼ë“¤ì€ Hibernate 웹 사ì´íŠ¸ ìƒì— ë§í¬ë˜ì–´ 있다."
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "Hibernate 웹사ì´íŠ¸ ìƒì˜ ê³µë™ì²´ ì˜ì—ì€ ì„¤ê³„ 패턴과 다양한 통합 솔루션들(Tomcat, JBoss AS, Struts, EJB 등.)ì— ê´€í•œ ì¢‹ì€ ë¦¬ì†ŒìŠ¤ì´ë‹¤."
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "ì§ˆë¬¸ì´ ìžˆë‹¤ë©´, Hibernate ìƒì— ë§í¬ë˜ì–´ 있는 ì‚¬ìš©ìž í¬ëŸ¼ì„ 사용하ë¼. 우리는 ë˜í•œ 버그 ë³´ê³ ì™€ 특징 ìš”ì²ë“¤ì„ 위한 JIRA ìŸì 추ì ì‹œìŠ¤í…œì„ ì œê³µí•œë‹¤. ë‹¹ì‹ ì´ Hibernateì˜ ê°œë°œì— ê´€ì‹¬ì´ ìžˆë‹¤ë©´, ê°œë°œìž ë©”ì¼ë§ ë¦¬ìŠ¤íŠ¸ì— ì°¸ì—¬í•˜ë¼. ë§Œì¼ ë‹¹ì‹ ì´ ì´ ë¬¸ì„œë¥¼ ë‹¹ì‹ ì˜ ì–¸ì–´ë¡œ 번ì—하는 ê²ƒì— ê´€ì‹¬ì´ ìžˆë‹¤ë©´, ê°œë°œìž ë©”ì¼ë§ ë¦¬ìŠ¤íŠ¸ì— ì ‘ì´‰í•˜ë¼."
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "Hibernate를 위한 ìƒìš© 개발 지ì›, ì œí’ˆ 지ì›, ê·¸ë¦¬ê³ êµìœ¡ì€ JBoss Inc를 통해 ì´ìš© 가능하다 (http://www.hibernate.org/SupportTraining/를 ë³´ë¼). Hibernate는 JBoss Professional Open Source product 프로ì 트ì´ê³ ì œí’ˆë“¤ì— ëŒ€í•œ JBoss Enterprise Middleware System (JEMS) suiteì˜ ì¤‘ëŒ€í•œ ì»´í¬ë„ŒíŠ¸ì´ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,672 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr "Criteria 질ì˜ë“¤"
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr "Hibernate는 ì§ê´€ì ì¸, 확장 가능한 criteria query API를 특징 짓는다."
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr "<literal>Criteria</literal> ì¸ìŠ¤í„´ìŠ¤ ìƒì„±í•˜ê¸°"
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr "<literal>org.hibernate.Criteria</literal>ì¸í„°íŽ˜ì´ìŠ¤ëŠ” íŠ¹ì • ì˜ì† í´ëž˜ìŠ¤ì— 대한 질ì˜ë¥¼ 표현한다. <literal>Session</literal>ì€ <literal>Criteria</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 íŒ©í† ë¦¬ì´ë‹¤."
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr "ê²°ê³¼ ì…‹ ì œí•œí•˜ê¸°"
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr "개별ì ì¸ ì§ˆì˜ ê¸°ì¤€ì€ <literal>org.hibernate.criterion.Criterion</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ì´ë‹¤. <literal>org.hibernate.criterion.Restrictions</literal> í´ëž˜ìŠ¤ëŠ” ì–´ë–¤ 미리 만들어진 <literal>Criterion</literal> íƒ€ìž…ë“¤ì„ ì–»ëŠ” íŒ©í† ë¦¬ ë©”ì†Œë“œë“¤ì„ ì •ì˜í•œë‹¤."
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr "ì œí•œë“¤ì€ ë…¼ë¦¬ì 으로 그룹지워질 ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr "미리 만들어진 criterion 타입들(<literal>Restrictions</literal> 서브í´ëž˜ìŠ¤ë“¤)ì˜ ì˜ì—ì´ ê½¤ 존재하지만, 특히 ìœ ìš©í•œ ê²ƒì€ ë‹¹ì‹ ìœ¼ë¡œ 하여금 SQLì„ ì§ì ‘ ì§€ì •í•˜ë„ë¡ í•´ì¤€ë‹¤."
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr "질ì˜ëœ ì—”í‹°í‹°ì˜ í–‰ aliasì— ì˜í•´ ëŒ€ì²´ëœ <literal>{alias}</literal> placeholder."
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr "criterionì„ ì–»ëŠ” 대안ì ì¸ ì ‘ê·¼ë²•ì€ <literal>Property</literal> ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° ê·¸ê²ƒì„ ì–»ëŠ” 것ì´ë‹¤. ë‹¹ì‹ ì€ <literal>Property.forName()</literal>ì„ í˜¸ì¶œí•˜ì—¬ <literal>Property</literal>를 ìƒì„±ì‹œí‚¬ 수 있다."
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr "ê²°ê³¼ë“¤ì„ ìˆœì„œì§€ìš°ê¸°(ordering)"
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr "ë‹¹ì‹ ì€ <literal>org.hibernate.criterion.Order</literal>를 사용하여 ê²°ê³¼ë“¤ì„ ìˆœì„œ(ordering)지울 수 있다."
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:81
+msgid "Associations"
+msgstr "<title>연관들</title>"
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr "ë‹¹ì‹ ì€ <literal>createCriteria()</literal>를 사용하여 ì—°ê´€ë“¤ì„ ë„¤ë¹„ê²Œì´íŠ¸í•¨ìœ¼ë¡œì¨ ê´€ê³„ëœ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ì„ 쉽게 ì§€ì •í• ìˆ˜ 있다."
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr "ë‘ ë²ˆì§¸ <literal>createCriteria()</literal>는 <literal>Criteria</literal>ì˜ ìƒˆë¡œìš´ ì¸ìŠ¤í„´ìŠ¤ë¥¼ 반환하며, ê·¸ê²ƒì€ <literal>kittens</literal> ì½œë ‰ì…˜ì˜ ìš”ì†Œë“¤ì„ ì°¸ì¡°í•œë‹¤ëŠ” ì ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr "ë‹¤ìŒ ëŒ€ì²´ 형ì‹ì€ ì–´ë–¤ 환경들ì—ì„œ ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr "(<literal>createAlias()</literal>는 <literal>Criteria</literal>ì˜ ìƒˆë¡œìš´ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ìƒì„±ì‹œí‚¤ì§€ 않는다.)"
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr "ì•žì˜ ë‘ ê°œì˜ ì§ˆì˜ë“¤ì— ì˜í•´ ë°˜í™˜ëœ <literal>Cat</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— ì˜í•´ ë³´ê´€ëœ kittens ì½œë ‰ì…˜ë“¤ì€ criteriaì— ì˜í•´ ì‚¬ì „-í•„í„°ë§ë˜ì§€ <emphasis>않는다</emphasis>는 ì ì„ ë…¸íŠ¸í•˜ë¼! ë§Œì¼ ë‹¹ì‹ ì´ criteria(기준)ê³¼ ì¼ì¹˜í•˜ëŠ” ê³ ì–‘ì´ ìƒˆë¼ë“¤ì„ 단지 ê²€ìƒ‰í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ <literal>ResultTransformer</literal>를 사용해야 한다."
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr "ë™ì ì¸ ì—°ê´€ 페ì¹"
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr "ë‹¹ì‹ ì€ <literal>setFetchMode()</literal>를 사용하여 실행 ì‹œì— ì—°ê´€ íŽ˜ì¹ ì˜ë¯¸ë¥¼ ì§€ì •í• ìˆ˜ 있다."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "ì´ ì§ˆì˜ëŠ” outer ì¡°ì¸ìœ¼ë¡œ <literal>mate</literal>와 <literal>kittens</literal> 모ë‘를 íŽ˜ì¹˜í• ê²ƒì´ë‹¤. 추가 ì •ë³´ëŠ” <xref linkend=\"performance-fetching\"/>ì„ ë³´ë¼."
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr "ì˜ˆì œ 질ì˜ë“¤"
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr "<literal>org.hibernate.criterion.Example</literal> í´ëž˜ìŠ¤ëŠ” 주어진 ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° ì§ˆì˜ ê¸°ì¤€(criterion)ì„ êµ¬ì¡°í™” 시키는 ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr "ë²„ì „ 프로í¼í‹°ë“¤, ì‹ë³„ìžë“¤, ì—°ê´€ê´€ê³„ë“¤ì´ ë¬´ì‹œëœë‹¤. ë””í´íŠ¸ë¡œ null ê°’ 프로í¼í‹°ë“¤ì´ ì œì™¸ëœë‹¤."
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr "ë‹¹ì‹ ì€ <literal>Example</literal>ì´ ì ìš©ë˜ëŠ” ë°©ë²•ì„ ì¡°ì •í• ìˆ˜ 있다."
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr "ë‹¹ì‹ ì€ ì—°ê´€ëœ ê°ì²´ë“¤ì— 대한 criteria(기준)ì„ ìœ„ì¹˜ì§€ìš°ëŠ”ë° examples를 ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr "Projections, aggregation ê·¸ë¦¬ê³ grouping"
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr "<literal>org.hibernate.criterion.Projections</literal> í´ëž˜ìŠ¤ëŠ” <literal>Projection</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 íŒ©í† ë¦¬ì´ë‹¤. 우리는 <literal>setProjection()</literal>ì„ í˜¸ì¶œí•˜ì—¬ í•˜ë‚˜ì˜ ì§ˆì˜ì— projection(투사,투ì˜)ì„ ì 용시킨다."
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr "criteria ì§ˆì˜ ë‚´ì—서는 명시ì ì¸ \"group by\"ê°€ 필수ì ì´ì§€ 않다. ì–´ë–¤ projection íƒ€ìž…ë“¤ì€ <emphasis>grouping projections</emphasis>들ì´ê²Œë” ì •ì˜ë˜ê³ , ê·¸ê²ƒì€ ë˜í•œ SQL <literal>group by</literal> ì ˆ ì†ì— 나타난다."
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr "alias는 ì„ íƒì 으로 projectionì— í• ë‹¹ë 수 있어서, 투사ëœ(projected) ê°’ì€ ì œí•œ(restriction)들 ë˜ëŠ” ordering들 ë‚´ì—ì„œ 참조ë 수 있다. 다ìŒì€ ì´ê²ƒì„ 행하는 ë‘ ê°œì˜ ë‹¤ë¥¸ 방법들ì´ë‹¤:"
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr "<literal>alias()</literal> 메소드와 <literal>as()</literal> 메소드는 ë˜ ë‹¤ë¥¸ alias ëœ <literal>Projection</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ ë‚´ì— í•˜ë‚˜ì˜ projection ì¸ìŠ¤í„´ìŠ¤ë¥¼ 간단하게 í¬ìž¥í•œë‹¤. 지름길로서, ë‹¹ì‹ ì´ projectionì„ projection ë¦¬ìŠ¤íŠ¸ì— ì¶”ê°€í• ë•Œ ë‹¹ì‹ ì€ alias를 í• ë‹¹í• ìˆ˜ 있다:"
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ projectionë“¤ì„ í‘œí˜„í•˜ëŠ”ë° <literal>Property.forName()</literal>ì„ ì‚¬ìš©í• ìˆ˜ 있다:"
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr "Detached 질ì˜ë“¤ê³¼ 서브질ì˜ë“¤"
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr "<literal>DetachedCriteria</literal> í´ëž˜ìŠ¤ëŠ” ë‹¹ì‹ ì—게 세션 ì˜ì—ì˜ ì™¸ë¶€ì—ì„œ 질ì˜ë¥¼ ìƒì„±ì‹œí‚¤ë„ë¡ í•˜ê³ , 그런 ë‹¤ìŒ ë‚˜ì¤‘ì— ì–´ë–¤ ìž„ì˜ì˜ <literal>Session</literal>ì„ ì‚¬ìš©í•˜ì—¬ ê·¸ê²ƒì„ ì‹¤í–‰í•˜ë„ë¡ í•œë‹¤."
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr "<literal>DetachedCriteria</literal>는 ë˜í•œ 서브질ì˜ë¥¼ í‘œí˜„í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤. 서브질ì˜ë“¤ì„ í¬í•¨í•˜ëŠ” Criterion ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ <literal>Subqueries</literal> ë˜ëŠ” <literal>Property</literal>를 통해 얻어질 수 있다."
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr "심지어 ìƒê´€ê´€ê³„ 지워진 서브질ì˜ë“¤ì´ 가능하다:"
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr "natural ì‹ë³„ìžì— ì˜í•œ 질ì˜ë“¤"
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr "ëŒ€ë¶€ë¶„ì˜ ì§ˆì˜ë“¤ì—ì„œ, criteria 질ì˜ë“¤ì„ í¬í•¨í•˜ì—¬, ì§ˆì˜ ìºì‹œëŠ” 매우 효율ì ì´ì§€ 않다. 왜ëƒí•˜ë©´ ì§ˆì˜ ìºì‹œ ë¹„ìœ íš¨ì„±ì´ ë„ˆë¬´ ìžì£¼ ë°œìƒí•˜ê¸° 때문ì´ë‹¤. 하지만, 우리가 ìºì‹œ ë¹„ìœ íš¨ì„± ì•Œê³ ë¦¬ì¦˜ì„ ìµœì í™” 시킬 수 있는 í•œ 가지 특별한 ì¢…ë¥˜ì˜ ì§ˆì˜ê°€ 존재한다: ìƒìˆ˜ natural í‚¤ì— ì˜í•œ 룩업. 몇몇 어플리케ì´ì…˜ë“¤ì—ì„œ, ì´ëŸ° ì¢…ë¥˜ì˜ ì§ˆì˜ê°€ ìžì£¼ ë°œìƒí•œë‹¤. criteria API는 ì´ ì“°ìž„ìƒˆë¥¼ 위한 특별한 설비를 ì œê³µí•œë‹¤."
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr "첫번째로 ë‹¹ì‹ ì€ <literal><natural-id></literal>를 사용하여 ë‹¹ì‹ ì˜ ì—”í‹°í‹°ì— ëŒ€í•œ natural 키를 매핑 시켜야 í•˜ê³ , second-level ìºì‹œ ì‚¬ìš©ì„ ê°€ëŠ¥í•˜ê²Œ 해야 한다."
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr "ì´ ê¸°ëŠ¥ì€ <emphasis>가변성 있는</emphasis> natural í‚¤ë“¤ì„ ê°€ì§„ ì—”í‹°í‹°ë“¤ì˜ ìš©ë„ë¡œ ê³ ì•ˆë˜ì–´ 있지 ì•ŠìŒì„ 노트하ë¼."
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr "다ìŒìœ¼ë¡œ , Hibernate ì§ˆì˜ ìºì‹œë¥¼ 사용 가능하ë„ë¡ í•˜ë¼."
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr "ì´ì œ <literal>Restrictions.naturalId()</literal>는 ìºì‹œ ì•Œê³ ë¦¬ì¦˜ì„ ë³´ë‹¤ 효율ì 으로 ì‚¬ìš©í• ìˆ˜ 있ë„ë¡ ìš°ë¦¬ì—게 허용해준다."
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1510 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr "HQL: 하ì´ë²„네ì´íŠ¸ ì§ˆì˜ ì–¸ì–´(Hibernate Query Language)"
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr "Hibernate는 (아주 ì˜ë„ì 으로) SQLê³¼ 매우 í¡ì‚¬í•˜ê²Œ ë³´ì´ëŠ” 극히 ê°•ë ¥í•œ ì§ˆì˜ ì–¸ì–´ë¥¼ êµ¬ë¹„í•˜ê³ ìžˆë‹¤. 그러나 ê·¸ êµ¬ë¬¸ì— ì˜í•´ 우롱당하지 ë§ë¼; HQLì€ ìƒì†, 다형성 ê·¸ë¦¬ê³ ì—°ê´€ê³¼ ê°™ì€ ê°œë…ë“¤ì„ ì´í•´í•˜ì—¬ì„œ, ì „ì²´ì 으로 ê°ì²´ 지향ì ì´ë‹¤."
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr "ëŒ€ì†Œë¬¸ìž êµ¬ë¶„"
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr "질ì˜ë“¤ì€ Java í´ëž˜ìŠ¤ë“¤ê³¼ 프로í¼í‹°ë“¤ì˜ ì´ë¦„ë“¤ì„ ì œì™¸í•˜ë©´ 대소문ìžë¥¼ 구분하지 않는다. ë”°ë¼ì„œ <literal>SeLeCT</literal>는 <literal>SELECT</literal>와 ê°™ê³ <literal>SELECT</literal>ì™€ë„ ê°™ì§€ë§Œ <literal>org.hibernate.eg.FOO</literal>는 <literal>org.hibernate.eg.Foo</literal>ê³¼ 같지 ì•Šê³ <literal>foo.barSet</literal>ì€ <literal>foo.BARSET</literal>ê³¼ 같지 않다."
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr "ì´ ë§¤ë‰´ì–¼ì€ ì†Œë¬¸ìž HQL 키워드를 사용한다. 몇몇 사용ìžë“¤ì€ 보다 ë‚˜ì€ ê°€ë…ì„±ì„ ìœ„í•´ ëŒ€ë¬¸ìž í‚¤ì›Œë“œë“¤ì„ ê°€ì§„ 질ì˜ë“¤ì„ 찾지만, 우리는 ìžë°” 코드 ì†ì— 삽입ë ë•Œ ì´ ì»¨ë²¤ì…˜ì´ ì¶”í•˜ë‹¤ëŠ” ì ì„ ë°œê²¬í•œë‹¤."
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr "from ì ˆ"
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr "가장 간단한 가능한 Hibernate 질ì˜ëŠ” ë‹¤ìŒ í˜•ì‹ì´ë‹¤:"
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr "<![CDATA[from eg.Cat]]>"
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr "ì´ê²ƒì€ <literal>eg.Cat</literal> í´ëž˜ìŠ¤ì˜ ëª¨ë“ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 간단하게 반환한다. 우리는 대개 í´ëž˜ìŠ¤ ì´ë¦„ì„ ìˆ˜ì‹í• 필요가 없다. 왜ëƒí•˜ë©´, <literal>auto-import</literal>ê°€ ë””í´íŠ¸ì´ê¸° 때문ì´ë‹¤. ë”°ë¼ì„œ 우리는 대개 í•ìƒ 단지 다ìŒê³¼ ê°™ì´ ìž‘ì„±í•œë‹¤:"
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr "<![CDATA[from Cat]]>"
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr "대개 ë‹¹ì‹ ì€ í•œ ê°œì˜ <emphasis>alias</emphasis>를 í• ë‹¹í• í•„ìš”ê°€ ìžˆì„ ê²ƒì´ë‹¤. 왜ëƒí•˜ë©´ ë‹¹ì‹ ì€ ì§ˆì˜ì˜ 다른 부분들ì—ì„œ <literal>Cat</literal>ì„ ì°¸ì¡°í•˜ê³ ìž ì›í• 것ì´ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr "<![CDATA[from Cat as cat]]>"
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr "ì´ ì§ˆì˜ëŠ” alias <literal>cat</literal>ì„ <literal>Cat</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì— í• ë‹¹í•˜ì—¬ì„œ, 우리는 ë‚˜ì¤‘ì— ì§ˆì˜ ì†ì—ì„œ ê·¸ alias를 ì‚¬ìš©í• ìˆ˜ ìžˆì„ ê²ƒì´ë‹¤. <literal>as</literal> 키워드는 옵션ì´ë‹¤; 우리는 ë˜í•œ 다ìŒê³¼ ê°™ì´ ìž‘ì„±í• ìˆ˜ 있다:"
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr "<![CDATA[from Cat cat]]>"
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr "여러 ê°œì˜ í´ëž˜ìŠ¤ë“¤ì€ cartesian product(ì¹´í‹°ì ¼ ê³±) ë˜ëŠ” \"í¬ë¡œìŠ¤\" ì¡°ì¸ìœ¼ë¡œ 귀결ë˜ì–´ ë‚˜íƒ€ë‚ ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr "<![CDATA[from Formula, Parameter]]>"
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr "<![CDATA[from Formula as form, Parameter as param]]>"
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr "로컬 ë³€ìˆ˜ë“¤ì— ëŒ€í•œ Java 네ì´ë° 표준들과 ì¼ì¹˜ë˜ê²Œ, 첫 소문ìžë¥¼ 사용하여 ì§ˆì˜ aliasë“¤ì„ ëª…ëª…í•˜ëŠ” ê²ƒì€ ì¢‹ì€ ìŠµê´€ìœ¼ë¡œ 간주ëœë‹¤ (예를 들면 <literal>domesticCat</literal>)."
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr "연관들과 ì¡°ì¸ë“¤"
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr "우리는 ë˜í•œ <literal>join</literal>ì„ ì‚¬ìš©í•˜ì—¬ , ì—°ê´€ëœ ì—”í‹°í‹°ë“¤ì— ë˜ëŠ” ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì˜ ìš”ì†Œë“¤ì—ë„ aliasë“¤ì„ í• ë‹¹í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr "<![CDATA[from Formula form full join form.parameter param]]>"
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr "지ì›ë˜ëŠ” join íƒ€ìž…ë“¤ì€ ANSI SQL로부터 ë¹Œë ¤ì™”ë‹¤"
+
+#: index.docbook:103
+msgid "inner join"
+msgstr "inner join"
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr "left outer join"
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr "right outer join"
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr "<literal>full join</literal> (대개 ìœ ìš©í•˜ì§€ ì•ŠìŒ)"
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr "<literal>inner join</literal>, <literal>left outer join</literal>, ê·¸ë¦¬ê³ <literal>right outer join</literal> êµ¬ì¡°ì²´ë“¤ì´ ì•½ì¹ë 수 있다."
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr "ë‹¹ì‹ ì€ HQL <literal>with</literal> 키워드를 사용하여 특별한 ì¡°ì¸ ì¡°ê±´ë“¤ì„ ì œê³µí• ìˆ˜ 있다."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " left join cat.kittens as kitten \n"
+ " with kitten.bodyWeight > 10.0]]>"
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr "게다가, \"fetch\" joinì€ ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ì´ë‚˜ ì—°ê´€ê´€ê³„ë“¤ì´ í•œ ê°œì˜ select를 사용하여, ê·¸ê²ƒë“¤ì˜ ë¶€ëª¨ ê°ì²´ë“¤ì— ë”°ë¼ ì´ˆê¸°í™” ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤. ì´ê²ƒì€ ì½œë ‰ì…˜ì˜ ê²½ìš°ì— íŠ¹ížˆ ìœ ìš©í•˜ë‹¤. ê·¸ê²ƒì€ ì—°ê´€ê´€ê³„ë“¤ê³¼ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ 매핑 파ì¼ì˜ outer joinê³¼ lazy ì„ ì–¸ë“¤ì„ íš¨ìœ¨ì 으로 오버ë¼ì´ë“œ 시킨다. 추가 ì •ë³´ëŠ” <xref linkend=\"performance-fetching\"/>ì„ ë³´ë¼."
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr "fetch joinì€ ëŒ€ê°œ alias를 í• ë‹¹í• í•„ìš”ê°€ 없다. 왜ëƒí•˜ë©´, ì—°ê´€ëœ ê°ì²´ë“¤ì´ <literal>where</literal> ì ˆ(ë˜ëŠ” ì–´ë–¤ 다른 ì ˆ) ì†ì— 사용ë˜ì§€ ì•Šì„ ê²ƒì´ê¸° 때문ì´ë‹¤. ë˜í•œ ì—°ê´€ëœ ê°ì²´ë“¤ì€ ì§ˆì˜ ê²°ê³¼ë“¤ ì†ì— ì§ì ‘ 반환ë˜ì§€ 않는다. ëŒ€ì‹ ê·¸ê²ƒë“¤ì€ ë¶€ëª¨ ê°ì²´ë¥¼ 통해 ì ‘ê·¼ë 수 있다. 우리가 alias를 필요로 í• ìˆ˜ 있는 ìœ ì¼í•œ ì´ìœ 는 ë” ë§Žì€ ì½œë ‰ì…˜ë“¤ì„ ìž¬ê·€ì 으로 ì¡°ì¸ íŽ˜ì¹ì‹œí‚¤ëŠ” 경우ì´ë‹¤:"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat \n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr "(ë¹„ë¡ <literal>scroll()</literal>ì´ ì‚¬ìš©ë 수 있ì„지ë¼ë„) <literal>fetch</literal> 구조체는 <literal>iterate()</literal>를 사용하여 호출ë˜ëŠ” 질ì˜ë“¤ ë‚´ì— ì‚¬ìš©ë 수 ì—†ìŒì„ 노트하ë¼. ì´ë“¤ 오í¼ë ˆì´ì…˜ë“¤ì´ ê²°ê³¼ í–‰ë“¤ì— ê¸°ì´ˆí•˜ê³ ìžˆê¸° ë•Œë¬¸ì— <literal>fetch</literal>는 <literal>setMaxResults()</literal> ë˜ëŠ” <literal>setFirstResult()</literal>ê³¼ 함께 사용ë˜ì§€ ë§ì•„야 하며, 그것들(ê²°ê³¼ 행들)ì€ ëŒ€ê°œ ê°ê°ì˜ eager ì½œë ‰ì…˜ 페ì¹ì— 대해 ì¤‘ë³µë“¤ì„ í¬í•¨í•˜ë¯€ë¡œ ë§Žì€ í–‰ë“¤ì´ ë‹¹ì‹ ì´ ê¸°ëŒ€í•˜ëŠ” ê²ƒì´ ì•„ë‹ˆë‹¤. <literal>fetch</literal>는 특별한 ìš©ë„ì˜ <literal>with</literal> ì¡°ê±´ê³¼ë„ í•¨ê»˜ 사용ë 수 없다.í•œ ê°œì˜ ì§ˆì˜ ë‚´ì— í•˜ë‚˜ ì´ìƒì˜ ì½œë ‰ì…˜ì„ ì¡°ì¸ íŽ˜ì¹ì‹œì¼œ ì¹´í‹°ì ¼ ê³±ì„ ìƒì„±ì‹œí‚¤ëŠ” ê²ƒì´ ê°€ëŠ¥í•œë°, ì´ ê²½ìš°ì— ì£¼ì˜í•˜ë¼. 다중 ì½œë ‰ì…˜ roleë“¤ì„ ì¡°ì¸ íŽ˜ì¹ì‹œí‚¤ëŠ” ê²ƒì€ ë˜í•œ 때때로 bag ë§¤í•‘ë“¤ì— ëŒ€í•´ ì˜!
ˆê¸°ì¹˜ ì•Šì€ ê²°ê³¼ë“¤ì„ ê°€ì ¸ë‹¤ì£¼ê¸° 때문ì—, ë‹¹ì‹ ì´ ì´ ê²½ìš°ì— ë‹¹ì‹ ì˜ ì§ˆì˜ë“¤ì„ 처방하는 ë°©ë²•ì— ëŒ€í•´ 주ì˜í•˜ë¼. 마지막으로 <literal>full join fetch</literal>와 <literal>right join fetch</literal>는 ì˜ë¯¸ê°€ 없다."
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ (ë°”ì´íŠ¸ì½”ë“œ 방편으로) property-ë ˆë²¨ lazy 페ì¹ì„ ì‚¬ìš©í• ê²½ìš°, Hibernateë¡œ 하여금 <literal>fetch all properties</literal>를 사용하여 (첫 번째 질ì˜ì—ì„œ) lazy 프로í¼í‹°ë“¤ì„ 즉시 페치하ë„ë¡ ê°•ì œì‹œí‚¤ëŠ” ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr "<![CDATA[from Document fetch all properties order by name]]>"
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr "join êµ¬ë¬¸ì˜ í˜•ì‹ë“¤"
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr "HQLì€ ë‘ ê°€ì§€ 형ì‹ì˜ ì—°ê´€ ì¡°ì¸ì„ 지ì›í•œë‹¤: <literal>암묵ì </literal> ê·¸ë¦¬ê³ <literal>명시ì </literal>."
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr "ì•žì˜ ì ˆì—ì„œ 보여진 질ì˜ë“¤ì€ ëª¨ë‘ join 키워드가 from ì ˆ ë‚´ì— ëª…ì‹œì 으로 사용ë˜ëŠ” <literal>명시ì ì¸</literal> 형ì‹ì„ 사용한다. ì´ê²ƒì€ 권장ë˜ëŠ” 형ì‹ì´ë‹¤."
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr "<literal>함축ì ì¸</literal> 형ì‹ì€ join 키워드를 사용하지 않는다. ëŒ€ì‹ ì—, ì—°ê´€ë“¤ì€ dot(.) 표기를 사용하여 \"dot-참조ëœë‹¤(dereferenced)\". <literal>함축ì ì¸</literal> ì¡°ì¸ë“¤ì€ ìž„ì˜ì˜ HQL ì ˆë“¤ë‚´ì— ë‚˜íƒ€ë‚ ìˆ˜ 있다. <literal>함축ì ì¸</literal> joinì€ ê²°ê³¼ë˜ëŠ” SQL 문장ì—ì„œ inner join으로 귀결ëœë‹¤."
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr "ì‹ë³„ìž ì†ì„± 참조하기"
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr "개략ì 으로 ë§í•˜ìžë©´, ì—”í‹°í‹°ì˜ ì‹ë³„ìž ì†ì„±ì„ 참조하는 2가지 ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr "<emphasis>엔티티가 idë¡œ ëª…ëª…ëœ ë¹„ì‹ë³„ìž ì†ì„±ì„ ì •ì˜í•˜ì§€ ì•ŠëŠ”ë‹¤ê³ ê°€ì •í•˜ë©´</emphasis> 특별한 ì†ì„±(소문ìž) <literal>id</literal>ê°€ ì—”í‹°í‹°ì˜ ì‹ë³„ìž ì†ì„±ì„ ì°¸ì¡°í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다."
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr "ë§Œì¼ ê·¸ 엔티티가 ëª…ëª…ëœ ì‹ë³„ìž ì†ì„±ì„ ì •ì˜í•˜ëŠ” 경우, ë‹¹ì‹ ì€ ê·¸ ì†ì„± ì´ë¦„ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr "composite ì‹ë³„ìž ì†ì„±ë“¤ì— 대한 ì°¸ì¡°ë“¤ì€ ë™ì¼í•œ 네ì´ë° ê·œì¹™ë“¤ì„ ë”°ë¥¸ë‹¤. ë§Œì¼ ê·¸ 엔티티가 idë¡œ ëª…ëª…ëœ ë¹„ì‹ë³„ìžë¥¼ ê°–ê³ ìžˆì„ ê²½ìš°, composite ì†ì„±ì€ ì˜¤ì§ ê·¸ê²ƒì˜ ì •ì˜ëœ ëª…ëª…ì— ì˜í•´ 참조ë 수 있다; ê·¸ë°–ì˜ ê²½ìš° 특별한 <literal>id</literal> ì†ì„±ì´ ì‹ë³„ìž ì†ì„±ì„ ì°¸ì¡°í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다."
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr "노트: ì´ê²ƒì€ ë²„ì „ 3.2.2ì—ì„œ 시작ë ë•Œ 현격하게 변경ë˜ì—ˆë‹¤. ì´ì „ ë²„ì „ë“¤ì—ì„œ, <literal>id</literal>는 <emphasis>í•ìƒ</emphasis> ê·¸ê²ƒì˜ ì‹¤ì œ ì´ë¦„ì— ê´€ê³„ì—†ì´ ì‹ë³„ìž ì†ì„±ì„ 참조했다. ê·¸ ê²°ì •ì˜ ë¶„ê¸°ì ì€ <literal>id</literal>ë¡œ ëª…ëª…ëœ ë¹„ì‹ë³„ìž ì†ì„±ë“¤ì´ Hibernate 질ì˜ë“¤ ë‚´ì—ì„œ ê²°ì½” 참조ë 수 없었다는 ì ì´ì—ˆë‹¤."
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr "select ì ˆ"
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr "<literal>select</literal> ì ˆì€ ì§ˆì˜ ê²°ê³¼ ì…‹ ì†ì— ë°˜í™˜í• ê°ì²´ë“¤ê³¼ 프로í¼í‹°ë“¤ì´ ì–´ëŠ ê²ƒì¸ì§€ë¥¼ ê³¨ë¼ ë‚´ë„ë¡ ê°•ì œí•œë‹¤. 다ìŒì„ ê²€í† í•˜ìž:"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr ""
+ "<![CDATA[select mate \n"
+ "from Cat as cat \n"
+ " inner join cat.mate as mate]]>"
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr "질ì˜ëŠ” 다른 <literal>Cat</literal>ë“¤ì˜ <literal>mate</literal>ë“¤ì„ select í• ê²ƒì´ë‹¤. ì‹¤ì œë¡œ ë‹¹ì‹ ì€ ì´ ì§ˆì˜ë“¤ì„ 다ìŒê³¼ ê°™ì´ ë³´ë‹¤ 축약형으로 í‘œí˜„í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr "<![CDATA[select cat.mate from Cat cat]]>"
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr "질ì˜ë“¤ì€ ì»´í¬ë„ŒíŠ¸ íƒ€ìž…ì˜ í”„ë¡œí¼í‹°ë“¤ì„ í¬í•¨í•˜ëŠ” ìž„ì˜ì˜ ê°’ íƒ€ìž…ì˜ í”„ë¡œí¼í‹°ë“¤ì„ ë°˜í™˜í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr "<literal>Family</literal> í´ëž˜ìŠ¤ê°€ ì 당한 ìƒì„±ìžë¥¼ ê°–ê³ ìžˆìŒì„ ê°€ì •í•˜ë©´, 질ì˜ë“¤ì€ 여러 ê°ì²´ë“¤ ê·¸ë¦¬ê³ /ë˜ëŠ” 프로í¼í‹°ë“¤ì„ <literal>Object[]</literal> íƒ€ìž…ì˜ ë°°ì—´ë¡œì„œ,"
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+ "<![CDATA[select mother, offspr, mate.name \n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr "ë˜ëŠ” <literal>List</literal>로서,"
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr "ë˜ëŠ” ì‹¤ì œ typesafe ìžë°” ê°ì²´ë¡œì„œ,"
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr "ë°˜í™˜í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr "ë‹¹ì‹ ì€ <literal>as</literal>를 사용하여 selectë˜ëŠ” 표현ì‹ë“¤ì— aliasë“¤ì„ í• ë‹¹í• ìˆ˜ 있다:"
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr "다ìŒì€ <literal>select new map</literal>ê³¼ 함께 사용ë ë•Œ 가장 ìœ ìš©í•˜ë‹¤:"
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr "ì´ ì§ˆì˜ëŠ” selectëœ ê°’ë“¤ì— ëŒ€í•œ alias로부터 í•œ ê°œì˜ <literal>Map</literal>ì„ ë°˜í™˜í•œë‹¤."
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr "집계 함수들"
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr "HQL 질ì˜ë“¤ì€ 프로í¼í‹°ë“¤ì— 대한 집계(aggregate) í•¨ìˆ˜ë“¤ì˜ ê²°ê³¼ë“¤ì„ ë°˜í™˜í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr "지ì›ë˜ëŠ” 집계 í•¨ìˆ˜ë“¤ì€ ë‹¤ìŒê³¼ 같다"
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr "avg(...), sum(...), min(...), max(...)"
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr "count(*)"
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr "count(...), count(distinct ...), count(all...)"
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr "ë‹¹ì‹ ì€ select ì ˆ ì†ì— ì‚°ìˆ ì—°ì‚°ìžë“¤, ì—°ê²° ì—°ì‚°ìž, ê·¸ë¦¬ê³ ì¸ì§€ëœ SQL í•¨ìˆ˜ë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있다:"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr ""
+ "<![CDATA[select cat.weight + sum(kitten.weight) \n"
+ "from Cat cat \n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr "<literal>distinct</literal> 키워드와 all <literal>all</literal>ê°€ 사용ë 수 ìžˆê³ SQLì˜ ê²½ìš°ì™€ ë™ì¼í•œ ì˜ë¯¸ë¥¼ 갖는다."
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr "Polymorphic(다형성) 질ì˜ë“¤"
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr "다ìŒê³¼ ê°™ì€ ì§ˆì˜:"
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr "ì€ <literal>Cat</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ ë¿ë§Œ 아니ë¼, ë˜í•œ <literal>DomesticCat</literal>ê³¼ ê°™ì€ ì„œë¸Œí´ëž˜ìŠ¤ë“¤ ë˜í•œ 반환한다. Hibernate 질ì˜ë“¤ì€ <literal>from</literal> ì ˆ ë‚´ì— <emphasis>ìž„ì˜ì˜</emphasis> ìžë°” í´ëž˜ìŠ¤ë‚˜ ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ ëª…ëª…í• ìˆ˜ 있다. 질ì˜ëŠ” ê·¸ í´ëž˜ìŠ¤ë¥¼ 확장하거나 ê·¸ ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 구현하는 ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ë°˜í™˜í• ê²ƒì´ë‹¤. ë‹¤ìŒ ì§ˆì˜ëŠ” ëª¨ë“ ì˜ì† ê°ì²´ë“¤ì„ ë°˜í™˜í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr "<![CDATA[from java.lang.Object o]]>"
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr "ì¸í„°íŽ˜ì´ìŠ¤ <literal>Named</literal>는 여러 가지 ì˜ì† í´ëž˜ìŠ¤ë“¤ì— ì˜í•´ 구현ë ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr "ì´ë“¤ 마지막 ë‘ ê°œì˜ ì§ˆì˜ë“¤ì€ 하나 ì´ìƒì˜ SQL <literal>SELECT</literal>를 필요로 í• ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼. ì´ê²ƒì€ <literal>order by</literal> ì ˆì´ ì •í™•í•˜ê²Œ ì „ì²´ ê²°ê³¼ ì…‹ì„ ìˆœì„œì§€ìš°ì§€ ì•ŠìŒì„ ì˜ë¯¸í•œë‹¤.(ê·¸ê²ƒì€ ë˜í•œ ë‹¹ì‹ ì´ <literal>Query.scroll()</literal>ì„ ì‚¬ìš©í•˜ì—¬ ì´ë“¤ 질ì˜ë“¤ì„ í˜¸ì¶œí• ìˆ˜ ì—†ìŒì„ ì˜ë¯¸í•œë‹¤)."
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr "where ì ˆ"
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr "<literal>where</literal> ì ˆì€ ë°˜í™˜ëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ 목ë¡ì„ ì œí•œì‹œí‚¤ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다. ë§Œì¼ aliasê°€ 존재하지 ì•Šì„ ê²½ìš°, ë‹¹ì‹ ì€ ì´ë¦„ì— ì˜í•´ 프로í¼í‹°ë“¤ì„ ì°¸ì¡°í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr "<![CDATA[from Cat where name='Fritz']]>"
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr "ë§Œì¼ í•œ ê°œì˜ aliasê°€ ì¡´ìž¬í• ê²½ìš°, í•˜ë‚˜ì˜ ìˆ˜ì‹ì–´ê°€ ë¶™ì€ í”„ë¡œí¼í‹° ì´ë¦„ì„ ì‚¬ìš©í•˜ë¼:"
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr "는 'Fritz'ë¡œ ëª…ëª…ëœ <literal>Cat</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 반환한다."
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr ""
+ "<![CDATA[select foo \n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr "는 <literal>Foo</literal>ì˜ <literal>startDate</literal> 프로í¼í‹°ì™€ ë™ì¼í•œ <literal>date</literal> 프로í¼í‹°ë¥¼ 가진 <literal>bar</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ê°€ 존재하는 <literal>Foo</literal>ì˜ ëª¨ë“ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ë°˜í™˜í• ê²ƒì´ë‹¤. 합성 경로 표현ì‹ë“¤ì€ <literal>where</literal> ì ˆì„ ë§¤ìš° ê°•ë ¥í•˜ê²Œ 만들어준다. 다ìŒì„ ê²€í† í•˜ìž:"
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr "ì´ ì§ˆì˜ëŠ” í…Œì´ë¸” (inner) joinì„ ê°€ì§„ SQL 질ì˜ë¡œ 번ì—ëœë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ë‹¤ìŒê³¼ ê°™ì€ ì–´ë–¤ ê²ƒì„ ìž‘ì„±í–ˆë‹¤ë©´"
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr ""
+ "<![CDATA[from Foo foo \n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr "ë‹¹ì‹ ì€ SQLì—ì„œ 네 ê°œì˜ í…Œì´ë¸” joinë“¤ì„ í•„ìš”ë¡œ 하는 í•˜ë‚˜ì˜ ì§ˆì˜ë¡œ ë낼 것ì´ë‹¤."
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr "<literal>=</literal> ì—°ì‚°ìžëŠ” 프로í¼í‹°ë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ ë˜í•œ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 비êµí•˜ëŠ”ë° ì‚¬ìš©ë 수 있다:"
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+ "<![CDATA[select cat, mate \n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr "특별한 프로í¼í‹°(소문ìž) <literal>id</literal>는 ê°ì²´ì˜ ìœ ì¼ ì‹ë³„ìžë¥¼ ì°¸ì¡°í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다. 추가 ì •ë³´ëŠ” <xref linkend=\"queryhql-identifier-property\"/>를 ë³´ë¼."
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr "ë‘ ë²ˆì§¸ 질ì˜ê°€ 효율ì ì´ë‹¤. í…Œì´ë¸” joinì´ í•„ìš” 없다!"
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr "composite(합성) ì‹ë³„ìžë“¤ì˜ 프로í¼í‹°ë“¤ì´ ë˜í•œ 사용ë 수 있다. <literal>Person</literal>ì´ <literal>country</literal>와 <literal>medicareNumber</literal>ë¡œ êµ¬ì„±ëœ composite ì‹ë³„ìžë¥¼ ê°–ëŠ”ë‹¤ê³ ê°€ì •í•˜ìž. ì‹ë³„ìž ì†ì„±ë“¤ì„ 참조하는 것과 ê´€ë ¨ëœ ì¶”ê°€ ì •ë³´ëŠ” 다시 <xref linkend=\"queryhql-identifier-property\"/>를 ë³´ë¼."
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr "다시 한번, ë‘ ë²ˆì§¸ 질ì˜ëŠ” í…Œì´ë¸” joinì„ í•„ìš”ë¡œ 하지 않는다."
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr "마찬가지로, 특별한 프로í¼í‹° <literal>class</literal>는 다형ì ì¸ ì˜ì†ì„±(polymorphic persistence)ì˜ ê²½ìš°ì— ì¸ìŠ¤í„´ìŠ¤ì˜ íŒë³„ìž(discriminator) ê°’ì— ì•¡ì„¸ìŠ¤í•œë‹¤. where ì ˆ ì†ì— ì‚½ìž…ëœ Java í´ëž˜ìŠ¤ ì´ë¦„ì€ ê·¸ê²ƒì˜ íŒë³„ìž(discriminator) 값으로 변환ë 것ì´ë‹¤."
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ì»´í¬ë„ŒíŠ¸ë“¤ ë˜ëŠ” composite ì‚¬ìš©ìž íƒ€ìž…ë“¤, ë˜ëŠ” ëª…ëª…ëœ ì»´í¬ë„ŒíŠ¸ íƒ€ìž…ë“¤ì˜ ì†ì„±ë“¤ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤. ìƒì„¸í•œ ê²ƒì€ <xref linkend=\"queryhql-components\"/>를 ë³´ë¼."
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr "\"ìž„ì˜ì˜\" íƒ€ìž…ì€ ë‹¤ìŒ ë°©ë²•ìœ¼ë¡œ joinì„ í‘œí˜„í•˜ëŠ” ê²ƒì„ ìš°ë¦¬ì—게 허용해주는, 특별한 프로í¼í‹°ë“¤ <literal>id</literal>와 <literal>class</literal>를 갖는다(여기서 <literal>AuditLog.item</literal>ì€ <literal><any></literal>ë¡œ ë§¤í•‘ëœ í”„ë¡œí¼í‹°ì´ë‹¤)."
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr ""
+ "<![CDATA[from AuditLog log, Payment payment \n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr "<literal>log.item.class</literal>와 <literal>payment.class</literal>는 ìœ„ì˜ ì§ˆì˜ ë‚´ì—ì„œ ì™„ì „ížˆ 다른 ë°ì´í„°ë² ì´ìŠ¤ ì»¬ëŸ¼ë“¤ì˜ ê°’ë“¤ì„ ì°¸ì¡°í• ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr "표현ì‹ë“¤"
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr "<literal>where</literal> ì ˆ ì†ì— 허용ë˜ëŠ” 표현ì‹ë“¤ì€ ë‹¹ì‹ ì´ SQLë¡œ ìž‘ì„±í• ìˆ˜ 있는 ëŒ€ë¶€ë¶„ì˜ ì¢…ë¥˜ì˜ ê²ƒë“¤ì„ í¬í•¨í•œë‹¤:"
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr "ì‚°ìˆ ì—°ì‚°ìžë“¤ <literal>+, -, *, /</literal>"
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr "ë°”ì´ë„ˆë¦¬ ë¹„êµ ì—°ì‚°ìžë“¤ <literal>=, >=, <=, <>, !=, like</literal>"
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr "논리 연산들 <literal>and, or, not</literal>"
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr "ê·¸ë£¹í•‘ì„ ë‚˜íƒ€ë‚´ëŠ” 괄호들 <literal>( )</literal>, indicating grouping"
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr "\"간단한\" 경우, <literal>case ... when ... then ... else ... end</literal>, ê·¸ë¦¬ê³ \"검색ì¸\" 경우, <literal>case when ... then ... else ... end</literal>"
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr "문ìžì—´ ì—°ê²° <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr "EJB-QL 3.0ì— ì˜í•´ ì •ì˜ëœ ìž„ì˜ì˜ 함수 ë˜ëŠ” 오í¼ë ˆì´í„°: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr "<literal>coalesce()</literal> ê·¸ë¦¬ê³ <literal>nullif()</literal>"
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr "numeric 값들ì´ë‚˜ temporal ê°’ë“¤ì„ ê°€ë…성 있는 문ìžì—´ë¡œ 변환시키는 <literal>str()</literal>"
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr "<literal>cast(... as ...)</literal>, 여기서 ë‘번 째 아규먼트는 Hibernate íƒ€ìž…ì˜ ì´ë¦„ì´ê³ , ANSI <literal>cast()</literal>와 <literal>extract()</literal>ê°€ 기반 ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ 지ì›ë 경우ì—는 <literal>extract(... from ...)</literal>."
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr "ì¡°ì¸ëœ ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ì˜ aliasë“¤ì— ì ìš©ë˜ëŠ”, HQL <literal>index()</literal> 함수"
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr "ì½œë ‰ì…˜ ê°’ì„ ê°€ì§„ 경로 표현ì‹ë“¤ì„ 취하는 HQL 함수들 : <literal>some, all, exists, any, in</literal>ì„ ì‚¬ìš©í•˜ì—¬ ì •ëŸ‰í™” ë 수 있는 특별한 <literal>elements()</literal>와 <literal>indices</literal> 함수들과 함께 <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>."
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr "<literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>ê³¼ ê°™ì´ ìž„ì˜ì˜ ë°ì´í„°ë² ì´ìŠ¤ ì§€ì› SQL ìŠ¤ì¹¼ë¼ í•¨ìˆ˜"
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr "JDBC-ìŠ¤íƒ€ì¼ ìœ„ì¹˜ 파ë¼ë¯¸í„°ë“¤ <literal>?</literal>"
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr "ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr "SQL 리터럴들 <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr "Java <literal>public static final</literal> ìƒìˆ˜ë“¤. <literal>eg.Color.TABBY</literal>"
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr "<literal>in</literal> ê³¼ <literal>between</literal>ì€ ë‹¤ìŒê³¼ ê°™ì´ ì‚¬ìš©ë 수 있다:"
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr "ê·¸ë¦¬ê³ ë¶€ì •í˜•ë“¤ì€ ë‹¤ìŒê³¼ ê°™ì´ ìž‘ì„±ë 수 있다"
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr "마찬가지로, <literal>is null</literal>ê³¼ <literal>is not null</literal>ì€ null ê°’ë“¤ì„ í…ŒìŠ¤íŠ¸í•˜ëŠ”ë° ì‚¬ìš©ë 수 있다."
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr "Booleanë“¤ì€ Hibernate 구성 ë‚´ì— HQL ì§ˆì˜ ì¹˜í™˜ë“¤ì„ ì„ ì–¸í•¨ìœ¼ë¡œì¨ í‘œí˜„ì‹ë“¤ ë‚´ì— ì‰½ê²Œ 사용ë 수 있다:"
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr "ì´ê²ƒì€ 키워드 <literal>true</literal>와 <literal>false</literal> í‚¤ì›Œë“œë“¤ì„ ì´ HQL로부터 번ì—ëœ SQLì—ì„œ 리터럴 <literal>1</literal>ê³¼ <literal>0</literal>으로 대체ë 것ì´ë‹¤:"
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr "<![CDATA[from Cat cat where cat.alive = true]]>"
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr "ë‹¹ì‹ ì€ íŠ¹ë³„í•œ 프로í¼í‹° <literal>size</literal>로서 ë˜ëŠ” 특별한 <literal>size()</literal> 함수로서 ì½œë ‰ì…˜ì˜ ì‚¬ì´ì¦ˆë¥¼ í…ŒìŠ¤íŠ¸í• ìˆ˜ 있다."
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr "ì¸ë±ì‹±ëœ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´, ë‹¹ì‹ ì€<literal>minindex</literal>와 <literal>maxindex</literal> í•¨ìˆ˜ë“¤ì„ ì‚¬ìš©í•˜ì—¬ 최소 ì¸ë±ìŠ¤ê³¼ 최대 ì¸ë±ìŠ¤ë¥¼ ì°¸ì¡°í• ìˆ˜ 있다. ìœ ì‚¬í•˜ê²Œ ë‹¹ì‹ ì€ <literal>minelement</literal>와 <literal>maxelement</literal> 함수를 사용하여 기본 íƒ€ìž…ì„ ê°€ì§„ ì½œë ‰ì…˜ì˜ ìµœì†Œ 요소 ë° ìµœëŒ€ 요소를 ì°¸ì¡°í• ìˆ˜ 있다."
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr "SQL 함수들 <literal>any, some, all, exists, in</literal>ì€ ì½œë ‰ì…˜ì˜ ìš”ì†Œ ë˜ëŠ” ì¸ë±ìŠ¤ 세트(<literal>elements</literal> 함수와 <literal>indices</literal> 함수), ë˜ëŠ” 서브질ì˜ì˜ 결과를 ì „ë‹¬í–ˆì„ ë•Œ 지ì›ëœë‹¤(아래를 ë³´ë¼)."
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr "ì´ë“¤ 구조체들-<literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal>-는 Hibernate3ì—ì„œ where ì ˆ ë‚´ì—서만 사용ë ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr "ì¸ë±ì‹± ëœ ì½œë ‰ì…˜ë“¤ì˜ ìš”ì†Œë“¤(배열들, 리스트들, map들)ì€ ì¸ë±ìŠ¤ì— ì˜í•´ 참조ë 수 있다(where ì ˆ 안ì—서만):"
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr "<literal>[]</literal> ë‚´ë¶€ì˜ í‘œí˜„ì‹ì€ ì‚°ìˆ í‘œí˜„ì‹¤ì¼ ìˆ˜ 있다."
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr "HQLì€ ë˜í•œ one-to-many ì—°ê´€ ë˜ëŠ” ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì˜ ìš”ì†Œë“¤ì— ëŒ€í•´ 미리 만들어진 <literal>index()</literal> 함수를 ì œê³µí•œë‹¤."
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr ""
+ "<![CDATA[select item, index(item) from Order order \n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr "기본 ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ ì œê³µë˜ëŠ” Scalar SQL í•¨ìˆ˜ë“¤ì´ ì‚¬ìš©ë ìˆ˜ë„ ìžˆë‹¤"
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr "ë‹¹ì‹ ì´ ì•„ì§ ì´ ëª¨ë“ ê²ƒì„ ë‚©ë“하지 못한다면, SQL ë‚´ì—ì„œ ë‹¤ìŒ ì§ˆì˜ê°€ ê°€ë…ì„±ì´ ì–¼ë§ˆë‚˜ ë§Žê³ ì ì€ì§€ë¥¼ ìƒê°í•´ë³´ë¼:"
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr "<emphasis>힌트</emphasis> : 다ìŒê³¼ ê°™ì€ ì–´ë–¤ 것"
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr "order by ì ˆ"
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr "질ì˜ì— ì˜í•´ ë°˜í™˜ëœ ë¦¬ìŠ¤íŠ¸ëŠ” ë°˜í™˜ëœ í´ëž˜ìŠ¤ ë˜ëŠ” ì»´í¬ë„ŒíŠ¸ë“¤ì˜ 프로í¼í‹°ì— ì˜í•´ 순서(ordering)지워질 수 있다:"
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr "<literal>asc</literal> 옵션 ë˜ëŠ” <literal>desc</literal> ì˜µì…˜ì€ ê°ê° 오름차순 ë˜ëŠ” 내림차순 ì •ë ¬ì„ ë‚˜íƒ€ë‚¸ë‹¤."
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr "group by ì ˆ"
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr "aggregate ê°’ë“¤ì„ ë°˜í™˜í•˜ëŠ” 질ì˜ëŠ” ë°˜í™˜ëœ í´ëž˜ìŠ¤ë‚˜ ì»´í¬ë„ŒíŠ¸ë“¤ì˜ 프로í¼í‹°ì— ì˜í•´ 그룹지워질 수 있다:"
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat) \n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr ""
+ "<![CDATA[select foo.id, avg(name), max(name) \n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr "ë˜í•œ <literal>having</literal> ì ˆì´ í—ˆìš©ëœë‹¤."
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat) \n"
+ "from Cat cat\n"
+ "group by cat.color \n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr "SQL 함수들과 집계 í•¨ìˆ˜ë“¤ì´ ê¸°ë³¸ ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ 지ì›ë 경우(예를 들어 MySQLì€ ì§€ì›ë˜ì§€ 않는다) <literal>having</literal> ì ˆê³¼ <literal>order by</literal> ì ˆ ì†ì— 허용ëœë‹¤."
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr "<literal>group by</literal> ì ˆë„ <literal>order by</literal> ì ˆ ì–´ëŠ ê²ƒë„ ì‚°ìˆ í‘œí˜„ì‹ë“¤ì„ í¬í•¨í• 수 없다는 ì ì„ ë…¸íŠ¸í•˜ë¼. ë˜í•œ Hibernate는 현재 그룹지워진 엔티티를 확장하지 ì•Šì•„ì„œ ë§Œì¼ <literal>cat</literal>ì˜ ëª¨ë“ ì†ì„±ë“¤ì´ 집계ë˜ì§€ ì•Šì„ ê²½ìš°ì— ë‹¹ì‹ ì´ <literal>group by cat</literal>ì„ ì“¸ìˆ˜ ì—†ìŒì„ 노트하ë¼. ë‹¹ì‹ ì€ ëª…ì‹œì 으로 ëª¨ë“ ì§‘ê³„ë˜ì§€ 않는 ì†ì„±ë“¤ì„ 리스트해야 한다."
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr "서브질ì˜ë“¤"
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr "subselectë“¤ì„ ì§€ì›í•˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ë“¤ì˜ 경우, Hibernate는 질ì˜ë“¤ ë‚´ì— ì„œë¸Œì§ˆì˜ë“¤ì„ 지ì›í•œë‹¤. 서브질ì˜ëŠ” 괄호로 ë¬¶ì—¬ì ¸ì•¼ 한다(ìžì£¼ SQL 집계함수 í˜¸ì¶œì— ì˜í•´). 심지어 서로 ìƒê´€ëœ 서브질ì˜ë“¤(외부 ì§ˆì˜ ë‚´ì—ì„œ alias를 참조하는 서브질ì˜ë“¤)ì´ í—ˆìš©ëœë‹¤."
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr "HQL 서브질ì˜ë“¤ì´ select ì ˆ ë˜ëŠ” where ì ˆ ë‚´ì—서만 ì¼ì–´ë‚ 수 있ìŒì„ 노트하ë¼."
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr "서브질ì˜ë“¤ì€ ë˜í•œ <literal>row value constructor</literal> êµ¬ë¬¸ì„ í™œìš©í• ìˆ˜ 있다. ìƒì„¸í•œ ê²ƒì€ <xref linkend=\"queryhql-tuple\"/>를 ë³´ë¼."
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr "HQL ì˜ˆì œë“¤"
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr "Hibernate 질ì˜ë“¤ì€ 매우 ê°•ë ¥í•˜ê³ ë³µìž¡í• ìˆ˜ 있다. 사실, ì§ˆì˜ ì–¸ì–´ì˜ íž˜ì€ Hibernateì˜ ì£¼ìš” íŒë§¤ í¬ì¸íŠ¸ë“¤ 중 하나ì´ë‹¤. 다ìŒì€ ë‚´ê°€ ìµœê·¼ì˜ í”„ë¡œì 트ì—ì„œ ì‚¬ìš©í–ˆë˜ ì§ˆì˜ë“¤ê³¼ 매우 ìœ ì‚¬í•œ 몇몇 ì˜ˆì œ 질ì˜ë“¤ì´ë‹¤. ë‹¹ì‹ ì´ ìž‘ì„±í•˜ê²Œ ë ëŒ€ë¶€ë¶„ì˜ ì§ˆì˜ë“¤ì€ ì´ê²ƒë“¤ë³´ë‹¤ 훨씬 간단하다는 ì ì„ ë…¸íŠ¸í•˜ë¼!"
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr "ë‹¤ìŒ ì§ˆì˜ëŠ” íŠ¹ì • ê³ ê°ì— 대한 ëª¨ë“ ì§€ë¶ˆë˜ì§€ ì•Šì€ ì£¼ë¬¸ë“¤ì˜ ì£¼ë¬¸ id, í•ëª©ë“¤ì˜ 개수, ê·¸ë¦¬ê³ ì£¼ë¬¸ì˜ ì „ì²´ 합계값 ê·¸ë¦¬ê³ ì£¼ì–´ì§„ 최소 ì „ì²´ 합계를 ì „ì²´ í•©ê³„ê°’ì— ë”°ë¼ ê²°ê³¼ë“¤ì„ ìˆœì„œì§€ì›Œì„œ 반환한다. 가격 ê²°ì •ì— ìžˆì–´, ê·¸ê²ƒì€ í˜„ìž¬ì˜ ì¹´íƒ€ë¡ì„ 사용한다. 귀결ë˜ëŠ” SQL 질ì˜ëŠ” <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal>, <literal>PRICE</literal> í…Œì´ë¸”ë“¤ì— ëŒ€í•œ 네 ê°œì˜ inner ì¡°ì¸ë“¤ê³¼ í•œ ê°œì˜(ìƒê´€ì§€ì›Œì§€ì§€ ì•Šì€) subselect를 ê°–ê³ ìžˆë‹¤."
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate \n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr "괴물 ê°™ì€ ê²ƒ! ì‹¤ì œë¡œ 실 ìƒí™œì—ì„œ, 나는 서브질ì˜ë“¤ì„ 매우 좋아하지 ì•Šì•„ì„œ, ë‚˜ì˜ ì§ˆì˜ëŠ” ì‹¤ì œë¡œ 다ìŒê³¼ 같았다:"
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr "ë‹¤ìŒ ì§ˆì˜ëŠ” 현재 사용ìžì— ì˜í•´ 가장 ìµœê·¼ì˜ ìƒíƒœ ë³€ê²½ì´ í–‰í•´ì¡Œë˜ <literal>AWAITING_APPROVAL</literal> ìƒíƒœì— 있는 ëª¨ë“ ì§€ë¶ˆë“¤ì„ ì œì™¸í•œ, ê°ê°ì˜ ìƒíƒœì— 있는 ì§€ë¶ˆë“¤ì˜ ê°œìˆ˜ë¥¼ 카운트 한다. ê·¸ê²ƒì€ <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>PAYMENT_STATUS_CHANGE</literal> í…Œì´ë¸”ë“¤ì— ëŒ€í•œ ë‘ ê°œì˜ inner ì¡°ì¸ë“¤ê³¼ í•˜ë‚˜ì˜ ìƒê´€ê´€ê³„ 지워진 subselect를 가진 SQL 질ì˜ë¡œ 변환ëœë‹¤."
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+ "<![CDATA[select count(payment), status.name \n"
+ "from Payment as payment \n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = ( \n"
+ " select max(change.timeStamp) \n"
+ " from PaymentStatusChange change \n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr "ë§Œì¼ ë‚´ê°€ <literal>statusChanges</literal> ì½œë ‰ì…˜ì„ setê°€ ì•„ë‹Œ listë¡œ 매핑했다면, ê·¸ 질ì˜ëŠ” 작성하기가 훨씬 ë” ê°„ë‹¨í–ˆì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+ "<![CDATA[select count(payment), status.name \n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr "ë‹¤ìŒ ì§ˆì˜ëŠ” í˜„ìž¬ì˜ ì‚¬ìš©ìžê°€ ì†í•´ 있는 ì¡°ì§ì˜ ëª¨ë“ ê³„ì •ë“¤ê³¼ 지불ë˜ì§€ ì•Šì€ ì§€ë¶ˆë“¤ì„ ë°˜í™˜í•˜ëŠ”ë° MS SQL Server <literal>isNull()</literal> 함수를 사용한다. ê·¸ê²ƒì€ <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal>, <literal>ORG_USER</literal> í…Œì´ë¸”ë“¤ì— ëŒ€í•œ 세 ê°œì˜ inner ì¡°ì¸ë“¤, í•˜ë‚˜ì˜ outer ì¡°ì¸, ê·¸ë¦¬ê³ í•˜ë‚˜ì˜ subselect를 가진 í•œ ê°œì˜ SQL 질ì˜ë¡œ 번ì—ëœë‹¤."
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr "몇몇 ë°ì´í„°ë² ì´ìŠ¤ë“¤ì˜ 경우, 우리는 (ìƒê´€ê´€ê³„ 지워진) subselect를 없앨 필요가 ìžˆì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr "대량 update와 delete"
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr "HQLì€ ì´ì œ <literal>update</literal>, <literal>delete</literal> ê·¸ë¦¬ê³ <literal>insert ... select ...</literal> ë¬¸ìž¥ë“¤ì„ ì§€ì›í•œë‹¤. ìƒì„¸í•œ ê²ƒì€ <xref linkend=\"batch-direct\"/>를 ë³´ë¼."
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr "íŒë“¤ & 트ë¦ë“¤"
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr "ë‹¹ì‹ ì€ ì‹¤ì œë¡œ ì§ˆì˜ ê²°ê³¼ë“¤ì„ ë°˜í™˜í•˜ì§€ ì•Šê³ ì„œ 그것들(ì§ˆì˜ ê²°ê³¼ë“¤)ì˜ ê°œìˆ˜ë¥¼ ì¹´ìš´íŠ¸í• ìˆ˜ 있다:"
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr "ì½œë ‰ì…˜ì˜ í¬ê¸°ì— ë”°ë¼ ê²°ê³¼ë¥¼ 순서(ordering)ì§€ìš°ë ¤ë©´, ë‹¤ìŒ ì§ˆì˜ë¥¼ 사용하ë¼:"
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr \n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ê°€ subselectë“¤ì„ ì§€ì›í• 경우, ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì§ˆì˜ì˜ where ì ˆ ë‚´ì— selection 사ì´ì¦ˆì— 대한 ì¡°ê±´ì„ ìœ„ì¹˜ì§€ìš¸ 수 있다:"
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ê°€ subselect를 지ì›í•˜ì§€ ì•Šì„ ê²½ìš°, ë‹¤ìŒ ì§ˆì˜ë¥¼ 사용하ë¼:"
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr "ì´ í•´ê²°ì±…ì´ inner ì¡°ì¸ ë•Œë¬¸ì— 0ê°œì˜ ë©”ì‹œì§€ë¥¼ 가진 <literal>User</literal>를 ë°˜í™˜í• ìˆ˜ 없으므로, ë‹¤ìŒ í˜•ì‹ì´ ë˜í•œ ìœ ìš©í•˜ë‹¤:"
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr "í•˜ë‚˜ì˜ JavaBeanì˜ í”„ë¡œí¼í‹°ë“¤ì€ ëª…ëª…ëœ ì§ˆì˜ íŒŒë¼ë¯¸í„°ë“¤ì— ë°”ì¸ë“œë 수 있다:"
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr "ì½œë ‰ì…˜ë“¤ì€ í•„í„°ë¥¼ 가진 <literal>Query</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 사용하여 쪼매김하는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤:"
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr "ì½œë ‰ì…˜ ìš”ì†Œë“¤ì€ ì§ˆì˜ í•„í„°ë¥¼ 사용하여 순서(ordering)지워지거나 그룹지워질 수 ë„ ìžˆë‹¤:"
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr "ë‹¹ì‹ ì€ ì½œë ‰ì…˜ì„ ì´ˆê¸°í™” 하지 ì•Šê³ ì„œ 그것(ì½œë ‰ì…˜)ì˜ í¬ê¸°ë¥¼ ì°¾ì„ ìˆ˜ 있다:"
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+
+#: index.docbook:985
+msgid "Components"
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤"
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤ì€ 단지 간단한 ê°’ ìœ í˜•ë“¤ì´ HQL 질ì˜ë“¤ ë‚´ì— ì‚¬ìš©ë 수 있는 ëª¨ë“ ë°©ë²•ìœ¼ë¡œ 사용ë 수 있다. ê·¸ê²ƒë“¤ì€ <literal>select</literal> ì ˆ ë‚´ì— ë‚˜íƒ€ë‚ ìˆ˜ 있다."
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr "<![CDATA[select p.name from from Person p]]>"
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr "<![CDATA[select p.name.first from from Person p]]>"
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr "여기서 Personì˜ name ì†ì„±ì€ ì»´í¬ë„ŒíŠ¸ì´ë‹¤. ì»´í¬ë„ŒíŠ¸ë“¤ì€ ë˜í•œ <literal>where</literal> ì ˆ ë‚´ì— ì‚¬ìš©ë 수 있다:"
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr "<![CDATA[from from Person p where p.name = :name]]>"
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤ì€ ë˜í•œ <literal>order by</literal> ì ˆ ë‚´ì— ì‚¬ìš©ë 수 있다:"
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr "<![CDATA[from from Person p order by p.name]]>"
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr "<![CDATA[from from Person p order by p.name.first]]>"
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr "ì»´í¬ë„ŒíŠ¸ë“¤ì— 대한 ë˜ ë‹¤ë¥¸ 공통ì ì¸ ì‚¬ìš©ì€ <xref linkend=\"queryhql-tuple\"/>row value constructorsì— ìžˆë‹¤."
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr "Row value constructor 구문"
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr "HQLì€ ANSI SQL <literal>row value constructor</literal> 구문(종종 <literal>tuple</literal> 구문ì´ë¼ 명명ëœë‹¤)ì˜ ì‚¬ìš©ì„ ì§€ì›í•œë‹¤. ë¹„ë¡ ë°ì´í„°ë² ì´ìŠ¤ê°€ ê·¸ ê°œë…ì„ ì§€ì›í•˜ì§€ ì•Šì„지ë¼ë„ 그러하다. 여기서 우리는 ì „í˜•ì 으로 ì»´í¬ë„ŒíŠ¸ë“¤ê³¼ ì—°ê´€ë˜ì–´ 있는 다중-ê°’ 비êµë“¤ì„ ì¼ë°˜ì 으로 ì–¸ê¸‰í•˜ê³ ìžˆë‹¤. name ì»´í¬ë„ŒíŠ¸ë¥¼ ì •ì˜í•˜ëŠ” Person 엔티티를 ê²€í† í•˜ìž:"
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr "ë¹„ë¡ ì•½ê°„ 장황스럽지만 ê·¸ê²ƒì€ ìœ íš¨í•œ 구문ì´ë‹¤. ì´ê²ƒì„ 약간 ë” ê°„ê²°í•˜ê²Œ ë§Œë“¤ê³ <literal>row value constructor</literal> êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì´ ì¢‹ë‹¤:"
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr "<literal>select</literal>ì ˆ ë‚´ì— ì´ê²ƒì„ ì§€ì •í•˜ëŠ” ê²ƒì´ ë˜í•œ ìœ ìš©í• ìˆ˜ 있다:"
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr "<literal>row value constructor</literal> êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ëŠ” ë˜ ë‹¤ë¥¸ 경우는 다중 ê°’ë“¤ì— ëŒ€í•´ 비êµí• 필요가 있는 서브 질ì˜ë“¤ì„ ì‚¬ìš©í• ë•Œì´ë‹¤:"
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ì´ êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ê³ ìž ì›í• ê²½ìš°ì— ê³ ë ¤í•´ì•¼ í• í•œ 가지는 질ì˜ê°€ 메타ë°ì´í„° ë‚´ì— ìžˆëŠ” ì»´í¬ë„ŒíŠ¸ 서브-ì†ì„±ë“¤ì˜ ìˆœì„œì— ì¢…ì†ë 것ì´ë¼ëŠ” ì ì´ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1044 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr "Native SQL"
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ì˜ native SQL dialectë¡œ 질ì˜ë“¤ì„ í‘œí˜„í• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì´ ì˜¤ë¼í´ì˜ ì§ˆì˜ ížŒíŠ¸ë“¤ ë˜ëŠ” <literal>CONNECT</literal> 키워드와 ê°™ì€ ë°ì´í„°ë² ì´ìŠ¤ ì§€ì •ì ì¸ íŠ¹ì§•ë“¤ì„ í™œìš©í•˜ê³ ìž ì›í• ê²½ìš°ì— ì´ê²ƒì´ ìœ ìš©í•˜ë‹¤. ê·¸ê²ƒì€ ë˜í•œ ì§ì ‘ì ì¸ SQL/JDBC ê¸°ë°˜ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ìœ¼ë¡œë¶€í„° Hibernateë¡œì˜ ë³´ë‹¤ 명료한 ì´ì „ 경로를 ì œê³µí•œë‹¤."
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr "Hibernate3ì€ ë˜í•œ ëª¨ë“ create, update, delete, load 오í¼ë ˆì´ì…˜ë“¤ì— 대해 (내장 í”„ë¡œì‹œì €ë“¤ì„ í¬í•¨í•˜ì—¬) ì†ìœ¼ë¡œ ìž‘ì„±ëœ SQLì„ ì§€ì •í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr "<literal>SQLQuery</literal> 사용하기"
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr "native SQL 질ì˜ë“¤ì˜ ì‹¤í–‰ì€ <literal>SQLQuery</literal> ì¸í„°íŽ˜ì´ìŠ¤ë¥¼ 통해 ì œì–´ë˜ë©°, ê·¸ê²ƒì€ <literal>Session.createSQLQuery()</literal>ì„ í˜¸ì¶œí•˜ì—¬ íšë“ëœë‹¤. 다ìŒì€ ì´ API를 질ì˜ì— 사용하는 ë°©ë²•ì„ ì„¤ëª…í•œë‹¤."
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr "ìŠ¤ì¹¼ë¼ ì§ˆì˜ë“¤"
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr "가장 기본ì ì¸ SQL 질ì˜ëŠ” 스칼ë¼ë“¤(값들)ì˜ ëª©ë¡ì„ 얻는 것ì´ë‹¤."
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr "ì´ê²ƒë“¤ì€ 둘다 CATS í…Œì´ë¸” ë‚´ì— ìžˆëŠ” ê°ê°ì˜ ì»¬ëŸ¼ì— ëŒ€í•œ ìŠ¤ì¹¼ë¼ ê°’ë“¤ì„ ê°€ì§„ Object ë°°ì—´ë“¤ì˜ List를 ë°˜í™˜í• ê²ƒì´ë‹¤. Hibernate는 반환ë˜ëŠ” ìŠ¤ì¹¼ë¼ ê°’ë“¤ì˜ ì‹¤ì œ 순서와 íƒ€ìž…ë“¤ì„ ë„ì¶œí•˜ëŠ”ë° ResultSetMetadata를 ì‚¬ìš©í• ê²ƒì´ë‹¤."
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr "<literal>ResultSetMetadata</literal> ì‚¬ìš©ì˜ ì˜¤ë²„í—¤ë“œë¥¼ 피하거나 간단하게는 반환ë˜ëŠ” ê²ƒì„ ë³´ë‹¤ 명시ì ì´ê²Œë” 하기 위해 우리는 <literal>addScalar()</literal>를 ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr "ì´ ì§ˆì˜ëŠ” 다ìŒì„ ì§€ì •í–ˆë‹¤:"
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr "SQL ì§ˆì˜ ë¬¸ìžì—´"
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr "ë°˜í™˜í• ì»¬ëŸ¼ë“¤ê³¼ 타입들"
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr "ì´ê²ƒì€ ì—¬ì „ížˆ Object ë°°ì—´ë“¤ì„ ë°˜í™˜í• ê²ƒì´ì§€ë§Œ, ì´ì œ ê·¸ê²ƒì€ <literal>ResultSetMetdata</literal>를 사용하지 ì•Šì„ ê²ƒì´ê³ ëŒ€ì‹ ì— ê¸°ë°˜ 결과셋으로부터 ID, NAME ê·¸ë¦¬ê³ BIRTHDATE ì»¬ëŸ¼ì„ ê°ê° Long, String ê·¸ë¦¬ê³ Short 타입으로 ë°˜í™˜í• ê²ƒì´ë‹¤. 심지어 ê·¸ 질ì˜ê°€ <literal>*</literal>를 ì‚¬ìš©í•˜ê³ ì„¸ ê°œì˜ ì—´ê±°ëœ ì»¬ëŸ¼ë“¤ 보다 ë” ë§Žì€ ê²ƒì„ ë°˜í™˜í• ìˆ˜ 있ì„지ë¼ë„, ì´ê²ƒì€ ë˜í•œ ì˜¤ì§ ì´ë“¤ 세 ê°œì˜ ì»¬ëŸ¼ë“¤ ë§Œì´ ë°˜í™˜ë ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr "스칼ë¼ë“¤ 중 몇몇 ë˜ëŠ” ì „ë¶€ì— ëŒ€í•œ 타입 ì •ë³´ë¥¼ 남겨ë‘는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr "ì´ê²ƒì€ 본질ì 으로 ì•žì˜ ê²ƒê³¼ ë™ì¼í•œ 질ì˜ì´ì§€ë§Œ, ì´ì œ <literal>ResultSetMetaData</literal>는 IDì˜ íƒ€ìž…ì´ ëª…ì‹œì 으로 ì§€ì •ë˜ì–´ 있으므로 NAMEê³¼ BIRTHDATEì˜ íƒ€ìž…ì„ ê²°ì •í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr "java.sql.Types returned from ResultSetMetaDataì´ Hibernate 타입들로 매핑ë˜ëŠ” ë°©ë²•ì€ Dialectì— ì˜í•´ ì œì–´ëœë‹¤. ë§Œì¼ íŠ¹ì • íƒ€ìž…ì´ ë§¤í•‘ë˜ì§€ 않거나 예ìƒë˜ëŠ” 타입으로 귀결ë˜ì§€ ì•Šì„ ê²½ìš°ì— Dialect ë‚´ì— ìžˆëŠ” <literal>registerHibernateType</literal>ì— ëŒ€í•œ í˜¸ì¶œë“¤ì„ í†µí•´ ê·¸ê²ƒì„ ë§žì¶¤í™” 시키는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr "Entity 질ì˜ë“¤"
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr "ìœ„ì˜ ì§ˆì˜ë“¤ì€ ìŠ¤ì¹¼ë¼ ê°’ë“¤ì„ ë°˜í™˜í•˜ëŠ” 것, 결과셋들로부터 \"ì›ëž˜ì˜\" ê°’ë“¤ì„ ê¸°ë³¸ì 으로 반환하는 ê²ƒì— ëŒ€í•œ ì „ë¶€ì˜€ë‹¤. 다ìŒì€ <literal>addEntity()</literal>를 통해 native sql 질ì˜ë¡œë¶€í„° 엔티티 ê°ì²´ë“¤ì„ 얻는 ë°©ë²•ì„ ë³´ì—¬ì¤€ë‹¤."
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr "ê·¸ 질ì˜ì— ì˜í•´ 반환ë˜ëŠ” 엔티티"
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr "Catì´ ì»¬ëŸ¼ ID, NAME ê·¸ë¦¬ê³ BIRTHDATE로서 매핑ëœë‹¤ê³ ê°€ì •í•˜ë©´, ìœ„ì˜ ì§ˆì˜ë“¤ì€ 둘다 ê°ê°ì˜ 요소가 í•˜ë‚˜ì˜ Cat ì—”í‹°í‹°ì¸ í•˜ë‚˜ì˜ List를 ë°˜í™˜í• ê²ƒì´ë‹¤."
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr "ë§Œì¼ ê·¸ 엔티티가 ë˜ ë‹¤ë¥¸ ì—”í‹°í‹°ì— ëŒ€í•´ <literal>many-to-one</literal>ë¡œ 매핑ë˜ì–´ 있다면 ë˜í•œ native 질ì˜ë¥¼ ì‹¤í–‰í• ë•Œ ì´ê²ƒì„ 반환하는 ê²ƒì´ í•„ìˆ˜ì ê³ , ê·¸ ë°–ì˜ ê²½ìš° ë°ì´í„°ë² ì´ìŠ¤ ì§€ì •ì ì¸ \"ì»¬ëŸ¼ì´ ë°œê²¬ë˜ì§€ 않았습니다\" 오류가 ì¼ì–´ë‚ 것ì´ë‹¤. 추가ì ì¸ ì»¬ëŸ¼ì€ * 표기를 ì‚¬ìš©í• ìžë™ì 으로 반환ë 것ì´ì§€ë§Œ, 우리는 ë‹¤ìŒ <literal>Dog</literal>ì— ëŒ€í•œ <literal>many-to-one</literal> ì˜ˆì œì—서처럼 명시ì ì¸ ê²ƒì„ ë” ì„ í˜¸í•œë‹¤:"
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr "ì´ê²ƒì€ cat.getDog()ì´ ê³ ìœ í•˜ê²Œ 기능하는 ê²ƒì„ í—ˆìš©í•œë‹¤."
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr "연관들과 ì½œë ‰ì…˜ë“¤ì„ ì²˜ë¦¬í•˜ê¸°"
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr "프ë½ì‹œë¥¼ 초기화 ì‹œí‚´ì— ìžˆì–´ 가능한 특별한 ë¼ìš´ë“œíŠ¸ë¦½ì„ 피하기 위해서 <literal>Dog</literal>ì—ì„œ eagerly join시키는 ê²ƒì´ ê°„ìœ¼í•˜ë‹¤. ì´ê²ƒì€ <literal>addJoin()</literal> 메소드를 통해 행해지는ë°, ê·¸ê²ƒì€ ì—°ê´€ì´ë‚˜ ì½œë ‰ì…˜ ë‚´ì—ì„œ ì¡°ì¸ì‹œí‚¤ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr "ì´ ì˜ˆì œì—ì„œ 반환ë˜ëŠ” <literal>Cat</literal>ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ì— 대한 ìž„ì˜ì˜ 특별한 ë¼ìš´ë“œí¬ë¦½ ì—†ì´ ì „ì²´ì 으로 ì´ˆê¸°í™”ëœ ê·¸ê²ƒë“¤ì˜ <literal>dog</literal> 프로í¼í‹°ë¥¼ 갖는다. 우리가 joinì˜ ëŒ€ìƒ í”„ë¡œí¼í‹° 경로를 ì§€ì •í•˜ëŠ” ê²ƒì„ ê°€ëŠ¥í•˜ë„ë¡ í•˜ê¸° 위해 í•˜ë‚˜ì˜ alias ì´ë¦„(\"cat\")ì„ ì¶”ê°€í–ˆìŒì„ 주지하ë¼. ëŒ€ì‹ ì— ì˜ˆë¥¼ 들어 <literal>Cat</literal>ì´ <literal>Dog</literal>ì— ëŒ€í•´ one-to-many를 가질 경우, ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ ë™ì¼í•œ eager joiningì„ í–‰í•˜ëŠ” ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤."
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr "ì´ ë‹¨ê³„ì—ì„œ 우리는 Hibernateì—ì„œ native 질ì˜ë“¤ì„ 사용가능하ë„ë¡ ë§Œë“¤ê¸° 위해 sql 질ì˜ë“¤ì„ 강화시키지는 ê²ƒì„ ì‹œìž‘í•˜ì§€ ì•Šê³ ì„œë„ native 질ì˜ë“¤ë¡œì„œ 가능한 ê²ƒì˜ í•œê³„ì— ë„ë‹¬í•˜ê³ ìžˆë‹¤; ë¬¸ì œì ë“¤ì€ ë™ì¼í•œ íƒ€ìž…ì˜ ì—¬ëŸ¬ ì—”í‹°í‹°ë“¤ì„ ë°˜í™˜í• ë•Œ ë˜ëŠ” ë””í´íŠ¸ alias/column ì´ë¦„ë“¤ì´ ì¶©ë¶„í•˜ì§€ ì•Šì„ ë•Œ ë°œìƒí•˜ê¸° 시작한다."
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr "여러 ê°œì˜ ì—”í‹°í‹°ë“¤ì„ ë°˜í™˜í•˜ê¸°"
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr "지금까지 ê²°ê³¼ ì…‹ 컬럼 ì´ë¦„ë“¤ì€ ë§¤í•‘ 문서 ë‚´ì— ì§€ì •ëœ ì»¬ëŸ¼ ì´ë¦„들과 ë™ì¼í•˜ë‹¤ê³ ê°€ì •ë˜ì–´ 있다. ë™ì¼í•œ ì»¬ëŸ¼ì´ í•˜ë‚˜ ì´ìƒì˜ í…Œì´ë¸” ë‚´ì—ì„œ ë‚˜íƒ€ë‚ ìˆ˜ 있기 때문ì—, ì´ê²ƒì€ 여러 ê°œì˜ í…Œì´ë¸”ë“¤ì„ ì¡°ì¸ì‹œí‚¤ëŠ” SQL 질ì˜ë“¤ì— 대해 ë¬¸ì œê°€ ë 수 있다."
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr "컬럼 alias ì£¼ìž…ì€ ë‹¤ìŒ ì§ˆì˜(아마 ì‹¤íŒ¨í• ê²ƒì´ë‹¤)ì—ì„œ 필요하다:"
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr "ì´ ì§ˆì˜ì˜ 목ì ì€ ë‹¨ìœ„ í–‰ 당 ë‘ ê°œì˜ Cat ì¸ìŠ¤í„´ìŠ¤ë“¤, í•˜ë‚˜ì˜ cat ê·¸ë¦¬ê³ ê·¸ê²ƒì˜ mother를 반환하는 것ì´ë‹¤. 왜ëƒí•˜ë©´ ê·¸ê²ƒë“¤ì´ ë™ì¼í•œ 컬럼 ì´ë¦„들로 매핑ë˜ì–´ 있기 ë•Œë¬¸ì— ì´ê²ƒì€ ì‹¤íŒ¨í• ê²ƒì´ê³ ë°ì´ë² ì´ìŠ¤ ìƒì—ì„œ ë°˜í™˜ëœ ì»¬ëŸ¼ aliasë“¤ì€ ì•„ë§ˆ 매핑들 ë‚´ì— ì§€ì •ëœ ì»¬ëŸ¼ë“¤(\"ID\" 와 \"NAME\")ê³¼ 같지 ì•Šì€ \"c.ID\", \"c.NAME\" ë“±ì˜ í˜•ì‹ì¼ 것ì´ë‹¤."
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr "ë‹¤ìŒ í˜•ì‹ì€ 컬럼 ì´ë¦„ 중복 취약ì ì„ ê°–ì§€ 않는다:"
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr "컬럼 aliasë“¤ì„ ì£¼ìž…í•˜ê¸° 위한 Hibernateìš© placeholderë“¤ì„ ê°€ì§„ SQL ì§ˆì˜ ë¬¸ìžì—´"
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr "ê·¸ 질ì˜ì— ì˜í•´ 반환ë˜ëŠ” 엔티티들"
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr "ìœ„ì— ì‚¬ìš©ëœ {cat.*} ê³¼ {mother.*} 표기는 \"ëª¨ë“ í”„ë¡œí¼í‹°ë“¤\"ì— ëŒ€í•œ ìƒëžµì´ë‹¤. 다른 방법으로 ë‹¹ì‹ ì€ ì»¬ëŸ¼ë“¤ì„ ëª…ì‹œì 으로 ì—´ê±°í• ìˆ˜ë„ ìžˆì§€ë§Œ, ì´ ê²½ìš°ì— ìš°ë¦¬ëŠ” Hibernateë¡œ 하여금 SQL 컬럼 aliasë“¤ì„ ê°ê°ì˜ ì»¬ëŸ¼ì— ì£¼ìž…ì‹œí‚¤ë„ë¡ ê°•ì œí•œë‹¤. 컬럼 alias를 위한 placeholder는 단지 ê·¸ í…Œì´ë¸” aliasì— ì˜í•´ 수ì‹ëœ 프로í¼í‹° ì´ë¦„ì´ë‹¤. ë‹¤ìŒ ì˜ˆì œì—ì„œ, 우리는 다른 í…Œì´ë¸”(cat_log)로부터 매핑 메타ë°ì´í„° ë‚´ì— ì„ ì–¸ëœ ê²ƒìœ¼ë¡œì˜ Cat들과 ê·¸ê²ƒë“¤ì˜ motherë“¤ì„ ê²€ìƒ‰í•œë‹¤. 우리는 우리가 좋다면 심지어 where ì ˆ ë‚´ì— í”„ë¡œí¼í‹° alias를 ì‚¬ìš©í• ìˆ˜ë„ ìžˆìŒì„ 주지하ë¼."
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr "alias 참조와 프로í¼í‹° 참조"
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr "ëŒ€ë¶€ë¶„ì˜ ê²½ìš°ì— ìœ„ì˜ alias ì£¼ìž…ì´ í•„ìš”í•˜ì§€ë§Œ, composite 프로í¼í‹°ë“¤, ìƒì† íŒë³„ìžë“¤ (inheritance discriminators), ì½œë ‰ì…˜ 등과 ê°™ì€ ë³´ë‹¤ 복잡한 매핑들과 ê´€ë ¨ëœ ì§ˆì˜ë“¤ì˜ 경우ì—는 ê³ ìœ í•œ aliasë“¤ì„ ì£¼ìž…ì‹œí‚¤ëŠ” ê²ƒì„ Hibernateì—게 í—ˆìš©í•˜ëŠ”ë° ì‚¬ìš©ë 몇몇 특별한 aliasë“¤ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr "ë‹¤ìŒ í…Œì´ë¸”ì€ alias ì£¼ìž…ì„ ì‚¬ìš©í•˜ëŠ” 다른 ê°€ëŠ¥ì„±ë“¤ì„ ë³´ì—¬ì¤€ë‹¤. 노트: ê²°ê³¼ ë‚´ì— ìžˆëŠ” alias ì´ë¦„ë“¤ì´ ì˜ˆì œì´ë©°, ê°ê°ì˜ alias는 사용ë ë•Œ í•˜ë‚˜ì˜ ìœ ì¼í•œ ì´ë¦„ê³¼ 아마 다른 ì´ë¦„ì„ ê°€ì§ˆ 것ì´ë‹¤."
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr "alias 주입 ì´ë¦„들"
+
+#: index.docbook:219
+msgid "Description"
+msgstr "<entry>설명</entry>"
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr "<entry>구문</entry>"
+
+#: index.docbook:223
+msgid "Example"
+msgstr "<entry>ì˜ˆì œ</entry>"
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr "간단한 프로í¼í‹°"
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr "{[aliasname].[propertyname]"
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr "A_NAME as {item.name}"
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr "composite 프로í¼í‹°"
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr "{[aliasname].[componentname].[propertyname]}"
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr "ì—”í‹°í‹°ì˜ íŒë³„ìž(Discriminator)"
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr "{[aliasname].class}"
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr "DISC as {item.class}"
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr "ì—”í‹°í‹°ì˜ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤"
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr "{[aliasname].*}"
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr "{item.*}"
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr "ì½œë ‰ì…˜ 키"
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr "{[aliasname].key}"
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr "ORGID as {coll.key}"
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr "ì½œë ‰ì…˜ì˜ id"
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr "{[aliasname].id}"
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr "EMPID as {coll.id}"
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr "ì½œë ‰ì…˜ì˜ ìš”ì†Œ"
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr "{[aliasname].element}"
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr "XID as {coll.element}"
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr "ì½œë ‰ì…˜ ë‚´ì— ìžˆëŠ” ìš”ì†Œì˜ í”„ë¡œí¼í‹°"
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr "{[aliasname].element.[propertyname]}"
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr "NAME as {coll.element.name}"
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr "ì½œë ‰ì…˜ ë‚´ì— ìžˆëŠ” ìš”ì†Œì˜ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤"
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr "{[aliasname].element.*}"
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr "{coll.element.*}"
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr "ì½œë ‰ì…˜ì˜ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤"
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr "{coll.*}"
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr "non-managed ì—”í‹°í‹°ë“¤ì„ ë°˜í™˜í•˜ê¸°"
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr "native sql 질ì˜ì— ResultTransformer를 ì 용하는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. 예를 들어 non-managed ì—”í‹°í‹°ë“¤ì„ ë°˜í™˜í•˜ê¸° 위해 ResultTransformer를 허용하는 것."
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr "ê²°ê³¼ 변환ìž(transformer)"
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr "ìœ„ì˜ ì§ˆì˜ëŠ” 초기화ë˜ì–´ ìžˆê³ NAMEê³¼ BIRTHNAMEì˜ ê°’ë“¤ì„ <literal>CatDTO</literal>ì˜ ëŒ€ì‘하는 프로í¼í‹°ë“¤ê³¼ 필드들 ì†ìœ¼ë¡œ 주입시킨 <literal>CatDTO</literal>ì˜ ë¦¬ìŠ¤íŠ¸ë¥¼ ë°˜í™˜í• ê²ƒì´ë‹¤."
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr "ìƒì† 처리하기"
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr "ìƒì†ì˜ 부분으로서 매핑ë˜ëŠ” ì—”í‹°í‹°ë“¤ì„ ì§ˆì˜í•˜ëŠ” native sql 질ì˜ë“¤ì€ baseclassì˜ ëª¨ë“ í”„ë¡œí¼í‹°ë“¤ì„ í¬í•¨í•´ì•¼ í•˜ê³ ê·¸ ëª¨ë“ ê²ƒì´ ì„œë¸Œí´ëž˜ìŠ¤í™” ë˜ì–´ì•¼ 한다."
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr "파ë¼ë¯¸í„°ë“¤"
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr "Native sql 질ì˜ë“¤ì€ 위치 파ë¼ë¯¸í„°ë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ì„ 지ì›í•œë‹¤:"
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr "ëª…ëª…ëœ SQL 질ì˜ë“¤"
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr "ëª…ëª…ëœ SQL 질ì˜ë“¤ì€ HQL 질ì˜ì™€ ë™ì¼í•œ 방법으로 매핑 문서 ì†ì— ì •ì˜ë 수 ìžˆê³ ì •í™•í•˜ê²Œ 호출ë ìˆ˜ë„ ìžˆë‹¤. ì´ ê²½ìš°ì—, 우리는 <literal>addEntity()</literal> í˜¸ì¶œì„ í•„ìš”ë¡œ 하지 <emphasis>않는다</emphasis>."
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr "<literal><return-join></literal> 요소와 <literal><load-collection></literal> 요소는 ì—°ê´€ë“¤ì„ ì¡°ì¸ì‹œí‚¤ê³ ì½œë ‰ì…˜ë“¤ì„ ê°ê° 초기화 시키는 질ì˜ë“¤ì„ ì •ì˜í•˜ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr "ëª…ëª…ëœ SQL 질ì˜ëŠ” ìŠ¤ì¹¼ë¼ ê°’ì„ ë°˜í™˜í• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì€ <literal><return-scalar></literal> 요소를 사용하여 컬럼 alias와 Hibernate íƒ€ìž…ì„ ì„ ì–¸í•´ì•¼ 한다:"
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr "ë‹¹ì‹ ì€ ì—¬ëŸ¬ ê°œì˜ ëª…ëª…ëœ ì§ˆì˜ë“¤ì„ 가로질러 재사용하거나 <literal>setResultSetMapping()</literal> API를 통해 결과셋 ë§¤í•‘ì •ë³´ë“¤ì„ ìž¬ì‚¬ìš©í•˜ê¸° 위해 <literal><resultset></literal> 요소 ì†ì— 결과셋 매핑 ì •ë³´ë“¤ì„ êµ¬ì²´í™” 시킬 수 있다."
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr "다른방법으로 ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ hbm 파ì¼ë“¤ ë‚´ì— ì§ì ‘ ìžë°” 코드로 ëœ ê²°ê³¼ì…‹ 매핑 ì •ë³´ë¥¼ ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr "명시ì 으로 column/alias ì´ë¦„ë“¤ì„ ì§€ì •í•˜ëŠ”ë° return-property 사용하기"
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr "Hibernateë¡œ 하여금 그것 ìžì‹ ì˜ aliasë“¤ì„ ë¼ì›Œë„£ë„ë¡ í•˜ê¸° 위해 <literal>{}</literal>-êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ëŠ” 것 ëŒ€ì‹ ì—, <literal><return-property></literal>로서 ë‹¹ì‹ ì€ ì‚¬ìš©í• ì»¬ëŸ¼ aliasë“¤ì´ ë¬´ì—‡ì¸ì§€ë¥¼ Hibernateì—게 명시ì 으로 ì•Œë ¤ì¤„ 수 있다."
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr "<literal><return-property></literal>는 ë˜í•œ 다중 ì»¬ëŸ¼ë“¤ì— ëŒ€í•´ ë™ìž‘한다. ì´ê²ƒì€ 다중-컬럼 프로í¼í‹°ë“¤ì— 대한 fine grained ì œì–´ë¥¼ í—ˆìš©í• ìˆ˜ 없는 <literal>{}</literal>-êµ¬ë¬¸ì„ ê°€ì§„ ì œì•½ì„ í•´ê²°í•´ì¤€ë‹¤."
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr "ì´ ì˜ˆì œì—ì„œ 우리는 ë¼ì›Œë„£ê¸°(injection)를 위해 <literal>{}</literal>-구문과 함께 <literal><return-property></literal>를 사용했ìŒì„ 주목하ë¼. 사용ìžë“¤ì´ 컬럼과 프로í¼í‹°ë“¤ì„ ì°¸ì¡°í•˜ê³ ìž ì›í•˜ëŠ” ë°©ë²•ì„ ì„ íƒí•˜ëŠ” ê²ƒì„ ì‚¬ìš©ìžë“¤ì—게 허용해줌으로ì¨."
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ë§¤í•‘ì´ í•œ ê°œì˜ íŒë³„ìž(discriminator )를 가질 경우 ë‹¹ì‹ ì€ íŒë³„ìž ì»¬ëŸ¼ì„ ì§€ì •í•˜ëŠ”ë° <literal><return-discriminator></literal>를 사용해야 한다."
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr "질ì˜ë¥¼ 위한 내장 í”„ë¡œì‹œì € 사용하기"
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr "Hibernate 3ì€ ë‚´ìž¥ í”„ë¡œì‹œì €ë“¤ê³¼ í•¨ìˆ˜ë“¤ì„ í†µí•œ ì§ˆì˜ ì§€ì›ì„ ë„입한다. ëŒ€ë¶€ë¶„ì˜ ë‹¤ìŒ ë¬¸ì„œëŠ” ì–‘ìž ëª¨ë‘ì— ë™ì¼í•˜ê²Œ ì ìš©ëœë‹¤. 내장 í”„ë¡œì‹œì €/함수는 Hibernate와 ë™ìž‘하는 ê²ƒì´ ê°€ëŠ¥í•˜ë„ë¡ ì²« 번째 out-파ë¼ë¯¸í„°ë¡œì„œ í•œ ê°œì˜ ê²°ê³¼ì…‹ì„ ë°˜í™˜í•´ì•¼ 한다. Oracle9 ì´ìƒì˜ ë²„ì „ì—ì„œ 그런 내장 í”„ë¡œì‹œì €ì— ëŒ€í•œ ì˜ˆì œëŠ” 다ìŒê³¼ 같다:"
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr "Hibernateì—ì„œ ì´ ì§ˆì˜ë¥¼ 사용하기 위해 ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ëª…ëª…ëœ ì§ˆì˜(a named query)를 통해 ê·¸ê²ƒì„ ë§¤í•‘í• í•„ìš”ê°€ 있다."
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr "내장 í”„ë¡œì‹œì €ë“¤ì€ í˜„ìž¬ 스칼ë¼ë“¤ê³¼ 엔티티들 ë§Œì„ ë°˜í™˜í•¨ì„ ì£¼ëª©í•˜ë¼. <literal><return-join></literal>ê³¼ <literal><load-collection></literal>ì€ ì§€ì›ë˜ì§€ 않는다."
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr "내장 í”„ë¡œì‹œì €ë“¤ì„ ì‚¬ìš©í•˜ëŠ” 규칙들/ì œì•½ë“¤"
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr "Hibernateì—ì„œ 내장 í”„ë¡œì‹œì €ë“¤ì„ ì‚¬ìš©í•˜ê¸° 위해서 í”„ë¡œì‹œì €ë“¤/í•¨ìˆ˜ë“¤ì€ ë‹¤ìŒ ëª‡ëª‡ ê·œì¹™ë“¤ì„ ë”°ë¼ì•¼ 한다. ë§Œì¼ ê·¸ê²ƒë“¤ì´ ê·¸ë“¤ ê·œì¹™ë“¤ì„ ë”°ë¥´ì§€ ì•Šì„ ê²½ìš° ê·¸ê²ƒë“¤ì€ Hibernate와 함께 사용 불가능하다. ë§Œì¼ ë‹¹ì‹ ì´ ì—¬ì „ížˆ ì´ë“¤ í”„ë¡œì‹œì €ë“¤ì„ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ <literal>session.connection()</literal>ì„ í†µí•´ ê·¸ê²ƒë“¤ì„ ì‹¤í–‰ì‹œì¼œì•¼ 한다. ë°ì´í„°ë² ì´ìŠ¤ 벤ë”ë“¤ì´ ë‹¤ë¥¸ 내장 í”„ë¡œì‹œì € ì˜ë¯¸ë¡ /êµ¬ë¬¸ì„ ê°–ê³ ìžˆê¸° 때문ì—, ê·œì¹™ë“¤ì€ ê°ê°ì˜ ë°ì´í„°ë² ì´ìŠ¤ì— ë”°ë¼ ì°¨ì´ê°€ 난다."
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr "내장 í”„ë¡œì‹œì € 질ì˜ë“¤ì€ <literal>setFirstResult()/setMaxResults()</literal>로서 쪽매김 ë 수 없다."
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr "권장ë˜ëŠ” 호출 형ì‹ì€ 표준 SQL92ì´ë‹¤: <literal>{ ? = call functionName(<parameters>) }</literal> ë˜ëŠ” <literal>{ ? = call procedureName(<parameters>}</literal>. Native 호출 êµ¬ë¬¸ì€ ì§€ì›ë˜ì§€ 않는다."
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr "Oracleì˜ ê²½ìš° ë‹¤ìŒ ê·œì¹™ë“¤ì´ ì ìš©ëœë‹¤:"
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr "í•˜ë‚˜ì˜ í•¨ìˆ˜ëŠ” í•˜ë‚˜ì˜ ê²°ê³¼ ì…‹ì„ ë°˜í™˜í•´ì•¼ 한다. í”„ë¡œì‹œì €ì˜ ì²« 번째 파ë¼ë¯¸í„°ëŠ” í•˜ë‚˜ì˜ ê²°ê³¼ ì…‹ì„ ë°˜í™˜í•˜ëŠ” í•˜ë‚˜ì˜ <literal>OUT</literal>ì´ì–´ì•¼ 한다. ì´ê²ƒì€ Oracle 9 ë˜ëŠ” 10ì—ì„œ í•˜ë‚˜ì˜ <literal>SYS_REFCURSOR</literal>를 사용하여 행해진다. Oracleì—ì„œ ë‹¹ì‹ ì€ <literal>REF CURSOR</literal> íƒ€ìž…ì„ ì •ì˜í• 필요가 있는ë°, Oracle ë³´ê³ ì„œë¥¼ ë³´ë¼."
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr "Sybase ë˜ëŠ” MS SQL serverì˜ ê²½ìš° ë‹¤ìŒ ê·œì¹™ë“¤ì´ ì ìš©ëœë‹¤:"
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr "í”„ë¡œì‹œì €ëŠ” í•œ ê°œì˜ ê²°ê³¼ ì…‹ì„ ë°˜í™˜í•´ì•¼ 한다. ì´ë“¤ ì„œë²„ë“¤ì´ ì—¬ëŸ¬ ê°œì˜ ê²°ê³¼ì…‹ë“¤ê³¼ ì—…ë°ì´íŠ¸ ì¹´ìš´íŠ¸ë“¤ì„ ë°˜í™˜ í• ìˆ˜ 있다/í• ê²ƒì´ì´ë¯€ë¡œ, Hibernate는 ê²°ê³¼ë“¤ì„ ë°˜ë³µ ìˆœí™˜í• ê²ƒì´ê³ ê·¸ê²ƒì˜ ë°˜í™˜ 값으로서 í•˜ë‚˜ì˜ ê²°ê³¼ ì…‹ì¸ ì²« 번째 결과를 ì·¨í• ê²ƒì´ë‹¤. ê·¸ ë°–ì˜ ëª¨ë“ ê²ƒì€ í기ë 것ì´ë‹¤."
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ í”„ë¡œì‹œì € ë‚´ì— <literal>SET NOCOUNT ON</literal>ì„ ì´ìš© 가능하게 í• ìˆ˜ 있다면 ê·¸ê²ƒì€ ì•„ë§ˆ 보다 효율ì ì´ê²Œ ë 것ì´ì§€ë§Œ ì´ê²ƒì€ í•„ìš” ì¡°ê±´ì´ ì•„ë‹ˆë‹¤."
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr "create, update ê·¸ë¦¬ê³ delete를 위한 맞춤형 SQL"
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr "Hibernate3는 create, update, delete 오í¼ë ˆì´ì…˜ë“¤ì„ 위한 맞춤형 ë¬¸ìž¥ë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있다. Hibernateì—ì„œ í´ëž˜ìŠ¤ì™€ ì½œë ‰ì…˜ ì˜ì†ìžë“¤ì€ 구성 ì‹œì— ìƒì„±ëœ 문ìžì—´ë“¤ì˜ 집합(insertsql, deletesql, updatesql 등)ì„ ì´ë¯¸ í¬í•¨í•˜ê³ 있다. <literal><sql-insert></literal>, <literal><sql-delete></literal>, <literal><sql-update></literal> 매핑 íƒœê·¸ë“¤ì€ ì´ë“¤ 문ìžì—´ë“¤ì„ 오버ë¼ì´ë“œ 시킨다:"
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr "SQLì´ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ ì§ì ‘ 실행ë˜ì–´ì„œ, ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ìž„ì˜ì˜ dialect를 사용하는 ê²ƒì´ ìžìœ ë¡ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ë°ì´í„°ë² ì´ìŠ¤ ì§€ì •ì ì¸ SQLì„ ì‚¬ìš©í• ê²½ìš° ì´ê²ƒì€ ë¬¼ë¡ ë‹¹ì‹ ì˜ ë§¤í•‘ì˜ ì´ì‹ì„±ì„ ê°ì†Œì‹œí‚¬ 것ì´ë‹¤."
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr "ë§Œì¼ <literal>callable</literal> ì†ì„±ì´ ì„¤ì •ë˜ë©´ 내장 í”„ë¡œì‹œì €ë“¤ì´ ì§€ì›ëœë‹¤:"
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr "위치 파ë¼ë¯¸í„°ë“¤ì€ Hibernateê°€ ê·¸ê²ƒë“¤ì„ ê¸°ëŒ€í•˜ëŠ” 것과 ê°™ì€ ìˆœì„œê°€ ë˜ì–´ì•¼ 하므로, 위치 파ë¼ë¯¸í„°ë“¤ì˜ 순서는 현재 ì ˆëŒ€ì 으로 중요하다."
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr "ë‹¹ì‹ ì€ <literal>org.hiberate.persister.entity</literal> ë ˆë²¨ë¡œ 디버그 ë¡œê¹…ì„ ì‚¬ìš© 가능하게 í•¨ìœ¼ë¡œì¨ ì˜ˆìƒëœ 순서를 ë³¼ 수 있다. ì´ ë ˆë²¨ì„ ì´ìš© 가능하게 하면 Hibernate는 ì—”í‹°í‹°ë“¤ì„ ìƒì„±ì‹œí‚¤ê³ , ì—…ë°ì´íŠ¸í•˜ê³ , ì‚ì œí•˜ëŠ”ë° ì‚¬ìš©ë˜ëŠ” ì •ì ì¸ SQLì„ ì¶œë ¥í• ê²ƒì´ë‹¤. (예ìƒë˜ëŠ” 결과를 ë³´ë ¤ë©´, Hibernate ìƒì„±ëœ ì •ì ì¸ sqlì„ ì˜¤ë²„ë¼ì´ë“œ 시키게 매핑 파ì¼ë“¤ ì†ì— ë‹¹ì‹ ì˜ ë§žì¶¤í˜• SQLì„ í¬í•¨ì‹œí‚¤ì§€ ì•Šë„ë¡ ì—¼ë‘ì— ë‘ë¼.)"
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr "Hibernateê°€ ë¬¸ìž¥ì˜ ì„±ê³µì„ ìœ„í•´ 몇몇 실행 ì‹œ ì²´í¬ë“¤ì„ 행하므로, 내장 í”„ë¡œì‹œì €ë“¤ì€ ëŒ€ë¶€ë¶„ì˜ ê²½ìš°ë“¤(ì½ê¸°:다른 경우들 보다 ê·¸ê²ƒì„ ë” ìž˜ 행한다)ì—ì„œ insertë˜ê³ /ì—…ë°ì´íŠ¸ë˜ê³ /ì‚ì œëœ í–‰ë“¤ì˜ ê°œìˆ˜ë¥¼ ë°˜í™˜í•˜ëŠ”ë° í•„ìš”í•˜ë‹¤. Hibernate는 í•ìƒ CUD 오í¼ë ˆì´ì…˜ë“¤ì— 대한 ìˆ«ìž ì¶œë ¥ 파ë¼ë¯¸í„°ë¡œì„œ 첫 번째 문장 파ë¼ë¯¸í„°ë¥¼ 등ë¡ì‹œí‚¨ë‹¤:"
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr "ë¡œë”©ì„ ìœ„í•œ 맞춤형 SQL"
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ 엔티티 ë¡œë”©ì„ ìœ„í•œ ë‹¹ì‹ ìžì‹ ì˜ SQL (ë˜ëŠ” HQL)ì„ ì„ ì–¸í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr "ì´ê²ƒì€ ì•žì„œ ë…¼ì˜í–ˆë“¯ì´ 단지 ëª…ëª…ëœ ì§ˆì˜ ì„ ì–¸ì´ë‹¤. ë‹¹ì‹ ì€ class 매핑 ì†ì— ì´ ëª…ëª…ëœ ì§ˆì˜ë¥¼ ì°¸ì¡°í• ìˆ˜ 있다:"
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr "ì´ê²ƒì€ 심지어 내장 í”„ë¡œì‹œì €ë“¤ì— ë™ìž‘한다."
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr "ë‹¹ì‹ ì€ ì½œë ‰ì…˜ ë¡œë”©ì„ ìœ„í•œ í•œ ê°œì˜ ì§ˆì˜ë¥¼ ì •ì˜í• ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr "ë‹¹ì‹ ì€ ì‹¬ì§€ì–´ ì¡°ì¸ íŽ˜ì¹ì— ì˜í•´ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì„ ë¡œë“œì‹œí‚¤ëŠ” í•˜ë‚˜ì˜ ì—”í‹°í‹°ë¥¼ ì •ì˜í• 수 있다:"
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,474 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "appended paragraph 1"
+msgstr "Tomcat으로 ë¹ ë¥¸ 시작"
+
+#: index.docbook:8
+msgid "appended paragraph 2"
+msgstr "Hibernate 시작하기"
+
+#: index.docbook:10
+msgid "appended paragraph 3"
+msgstr "ì´ íŠœí† ë¦¬ì–¼ì€ ì›¹ ê¸°ë°˜ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ìš© Apache Tomcat 서블릿 컨테ì´ë„ˆì— 대한 Hibernate 3.0 ì…‹ì—…ì„ ì„¤ëª…í•œë‹¤(우리는 ë²„ì „ 4.1ì„ ì‚¬ìš©í–ˆë‹¤. 5.0ì— ëŒ€í•œ ì°¨ì´ì ë“¤ì€ ì ì„ ê²ƒì´ë‹¤). Hibernate는 ëª¨ë“ ì£¼ìš” J2EE 어플리케ì´ì…˜ ì„œë²„ë“¤ì˜ ê´€ë¦¬ë˜ëŠ” 환경ì—ì„œ 잘 ë™ìž‘í•˜ê³ , ë˜ëŠ” 심지어 ìŠ¤íƒ ë“œì–¼ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì—ì„œë„ ìž˜ ë™ìž‘ 한다. ì´ íŠœí† ë¦¬ì–¼ì— ì‚¬ìš©ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ ì‹œìŠ¤í…œì€ PostgreSQL 7.4ì´ê³ , 다른 ë°ì´í„°ë² ì´ìŠ¤ì— 대한 지ì›ì€ 단지 Hibernate SQL dialect 구성과 커넥션 프로í¼í‹°ë“¤ì„ 변경시키는 것ì—만 관계ëœë‹¤."
+
+#: index.docbook:18
+msgid "appended paragraph 4"
+msgstr "ë¨¼ì € 우리는 ëª¨ë“ í•„ìˆ˜ì ì¸ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ Tomcat 설치 ìž¥ì†Œì— ë³µì‚¬í•´ì•¼ 한다. 우리는 ì´ íŠœí† ë¦¬ì–¼ì„ ìœ„í•´ 별ë„ì˜ ì›¹ 컨í…스트(<literal>webapps/quickstart</literal>)를 사용하며, ë”°ë¼ì„œ 우리는 ì „ì— ë¼ì´ë¸ŒëŸ¬ë¦¬ 검색 경로 (<literal>TOMCAT/common/lib</literal>)와 <literal>webapps/quickstart/WEB-INF/lib</literal> (JAR 파ì¼ë“¤ì˜ 경우)와 <literal>webapps/quickstart/WEB-INF/classes</literal> ë‚´ ì— ìžˆëŠ” 컨í…스트 ë ˆë²¨ì—ì„œ í´ëž˜ìŠ¤ë¡œë” ì–‘ìžë¥¼ ê³ ë ¤í•´ì•¼ 한다. 우리는 ë‘ ê°œì˜ í´ëž˜ìŠ¤ë¡œë” ë ˆë²¨ë“¤ì„ ì „ì— classpath와 컨í…스트 classpath로서 언급한다."
+
+#: index.docbook:27
+msgid "appended paragraph 5"
+msgstr "ì´ì œ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ ë‘ ê°œì˜ classpathë“¤ì— ë³µì‚¬í•˜ë¼:"
+
+#: index.docbook:33
+msgid "appended paragraph 6"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ ìš© JDBC ë“œë¼ì´ë²„를 ì „ì— classpathë¡œ 복사하ë¼. ì´ê²ƒì€ Tomcatì— ë²ˆë“¤ë¡œêµ¬ì„±ëœ DBCP 커넥션 í’€ ì†Œí”„íŠ¸ì›¨ì–´ì— í•„ìš”í•˜ë‹¤. Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ ìƒì—ì„œ SQLì„ ì‹¤í–‰ì‹œí‚¤ëŠ”ë° JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì‚¬ìš©í•˜ë¯€ë¡œ, ë‹¹ì‹ ì€ í’€ë§ëœ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì œê³µí•´ì•¼ 하거나, ì§ì ‘ 지ì›ë˜ëŠ” 풀들(C3P0, Proxool) 중 하나를 사용하기 위해 Hibernate를 구성해야 한다. ì´ íŠœí† ë¦¬ì–¼ì„ ìœ„í•´, (PostgreSQL 7.4와 JDK 1.4ìš©) <literal>pg74jdbc3.jar</literal> ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ ì „ì— classloaders 경로로 복사하ë¼. ë§Œì¼ ë‹¹ì‹ ì´ ë‹¤ë¥¸ ë°ì´í„°ë² ì´ìŠ¤ë¥¼ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, 간단하게 ê·¸ê²ƒì˜ ì ì ˆí•œ JDBC ë“œë¼ì´ë²„를 복사하ë¼."
+
+#: index.docbook:43
+msgid "appended paragraph 7"
+msgstr "ê·¸ ë°–ì˜ ì–´ë–¤ ê²ƒì„ Tomcat ë‚´ì˜ ì „ì— í´ëž˜ìŠ¤ë¡œë” ê²½ë¡œì— ë³µì‚¬í•˜ì§€ ë§ë¼. ë˜ëŠ” ë‹¹ì‹ ì€ Log4j, commons-logging ê·¸ë¦¬ê³ ë‹¤ë¥¸ ê²ƒë“¤ì„ í¬í•¨í•˜ëŠ” 여러 가지 ë„êµ¬ë“¤ì— ê´€ë ¨ëœ ë¬¸ì œì ë“¤ì„ ì–»ê²Œ ë 것ì´ë‹¤. ê°ê°ì˜ 웹 어플리케ì´ì…˜ì— 대해 컨í…스트 classpath를 사용하ë¼. 즉 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ <literal>WEB-INF/lib</literal>ì— ë³µì‚¬í•˜ê³ , ë‹¹ì‹ ìžì‹ ì˜ í´ëž˜ìŠ¤ë“¤ê³¼ 구성 파ì¼ë“¤/프로í¼í‹° 파ì¼ë“¤ì„ <literal>WEB-INF/classes</literal>ì— ë³µì‚¬í•˜ë¼. ë‘ ë””ë ‰í† ë¦¬ë“¤ ì–‘ìžëŠ” ë””í´íŠ¸ë¡œ 컨í…스트 classpath ë‚´ì— ìžˆë‹¤."
+
+#: index.docbook:52
+msgid "appended paragraph 8"
+msgstr "Hibernate는 JAR ë¼ì´ë¸ŒëŸ¬ë¦¬ë¡œì„œ 패키지화 ë˜ì–´ 있다. <literal>hibernate3.jar</literal> 파ì¼ì€ 어플리케ì´ì…˜ì˜ 다른 í´ëž˜ìŠ¤ë“¤ê³¼ 함께 컨í…스트 classpath ì†ì— 복사ë˜ì–´ì•¼ 한다. Hibernate는 실행 ì‹œì— ì–´ë–¤ ì œ 3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ í•„ìš”ë¡œí•˜ê³ , ì´ê²ƒë“¤ì€ <literal>lib/</literal> ë””ë ‰í† ë¦¬ ë‚´ì˜ Hibernate ë°°í¬ë³¸ì— 번들화ë˜ì–´ 있다; <xref linkend=\"3rdpartylibs\"/>를 ë³´ë¼. 필요한 ì œ3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 컨í…스트 classpathë¡œ 복사하ë¼."
+
+#: index.docbook:62
+msgid "appended paragraph 9"
+msgstr "Hibernate ì œ3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬"
+
+#: index.docbook:70
+msgid "appended paragraph 10"
+msgstr "ë¼ì´ë¸ŒëŸ¬ë¦¬"
+
+#: index.docbook:73
+msgid "appended paragraph 11"
+msgstr "<entry>설명</entry>"
+
+#: index.docbook:80
+msgid "appended paragraph 12"
+msgstr "antlr (필수)"
+
+#: index.docbook:83
+msgid "appended paragraph 13"
+msgstr "Hibernate는 ì§ˆì˜ íŒŒì„œë“¤ì„ ì‚°ì¶œí•˜ëŠ”ë° ANTLRì„ ì‚¬ìš©í•˜ê³ , ì´ ë¼ì´ë¸ŒëŸ¬ë¦¬ëŠ” ë˜í•œ 실행 ì‹œì— í•„ìš”í•˜ë‹¤."
+
+#: index.docbook:89
+msgid "appended paragraph 14"
+msgstr "dom4j (필수)"
+
+#: index.docbook:92
+msgid "appended paragraph 15"
+msgstr "Hibernate는 XML 구성과 XML 매핑 메타ë°ì´í„° 파ì¼ë“¤ì„ íŒŒì‹±í•˜ëŠ”ë° dom4j를 사용 한다."
+
+#: index.docbook:98
+msgid "appended paragraph 16"
+msgstr "CGLIB, asm (필수)"
+
+#: index.docbook:101
+msgid "appended paragraph 17"
+msgstr "Hibernate는 (Java reflectionê³¼ 결합하여) 런타임 ì‹œì— í´ëž˜ìŠ¤ë“¤ì„ ê³ ì–‘ì‹œí‚¤ëŠ”ë° ì½”ë“œ ìƒì„± ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ 사용한다."
+
+#: index.docbook:107
+msgid "appended paragraph 18"
+msgstr "Commons Collections, Commons Logging (필수)"
+
+#: index.docbook:110
+msgid "appended paragraph 19"
+msgstr "Hibernate는 Apache Jakarta Commons 프로ì 트로부터 다양한 ìœ í‹¸ë¦¬í‹° ë¼ì´ë¸ŒëŸ¬ë¦¬ ë“¤ì„ ì‚¬ìš©í•œë‹¤."
+
+#: index.docbook:116
+msgid "appended paragraph 20"
+msgstr "EHCache (필수)"
+
+#: index.docbook:119
+msgid "appended paragraph 21"
+msgstr "Hibernate는 second-level ìºì‹œë¥¼ 위한 다양한 ìºì‹œ 프로바ì´ë”ë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있다. ë§Œì¼ êµ¬ì„±ì—ì„œ 변하지 ì•Šì„ ê²½ìš° EHCacheê°€ ë””í´íŠ¸ ìºì‹œ 프로바ì´ë”ì´ë‹¤."
+
+#: index.docbook:125
+msgid "appended paragraph 22"
+msgstr "Log4j (옵션)"
+
+#: index.docbook:128
+msgid "appended paragraph 23"
+msgstr "Hibernate는 기본 로깅 메커니즘으로서 Log4j를 ì‚¬ìš©í• ìˆ˜ 있는, Commons Logging API를 사용한다. ë§Œì¼ Log4j ë¼ì´ë¸ŒëŸ¬ë¦¬ê°€ 컨í…스트 ë¼ì´ë¸ŒëŸ¬ë¦¬ ë””ë ‰í† ë¦¬ ì†ì—ì„œ ì´ìš© 가능하다면, Commons Loggingì€ Log4j와 컨í…스트 classpath ë‚´ì— ìžˆëŠ” <literal>log4j.properties</literal> êµ¬ì„±ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. Log4jì— ëŒ€í•œ ì˜ˆì œ properties 파ì¼ì€ Hibernate ë°°í¬ë³¸ì— 번들화 ë˜ì–´ 있다. ë”°ë¼ì„œ ë‹¹ì‹ ì´ ì´ë©´ì—ì„œ ë¬´ì—‡ì´ ì§„í–‰ë˜ëŠ” ì§€ì„ ë³´ê³ ìž ì›í• ê²½ìš°ì— log4j.jar와 (<literal>src/</literal>ì— ìžˆëŠ”) 구성 파ì¼ì„ ë‹¹ì‹ ì˜ ì»¨í…스트 classpath ì†ìœ¼ë¡œ 복사하ë¼."
+
+#: index.docbook:138
+msgid "appended paragraph 24"
+msgstr "필수 여부?"
+
+#: index.docbook:141
+msgid "appended paragraph 25"
+msgstr "Hibernate ë°°í¬ë³¸ ë‚´ì— ìžˆëŠ” <literal>lib/README.txt</literal> 파ì¼ì„ 살펴보ë¼. ì´ê²ƒì€ Hibernateì— ë°°í¬ëœ ì œ 3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì˜ ìµœì‹ ëª©ë¡ì´ë‹¤. ë‹¹ì‹ ì€ ê·¸ê³³ì— ì—´ê±°ëœ ëª¨ë“ í•„ìˆ˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ê³¼ 옵션 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 찾게 ë 것ì´ë‹¤(여기서 \"빌드 ì‹œ 필요함\"ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ì•„ë‹ˆë¼ Hibernateì— ëŒ€í•œ ì˜ë¯¸ìž„ì„ ë…¸íŠ¸í•˜ë¼)."
+
+#: index.docbook:152
+msgid "appended paragraph 26"
+msgstr "우리는 ì´ì œ Tomcatê³¼ Hibernate ì–‘ìžì—ì„œ ë°ì´í„°ë² ì´ìŠ¤ 커넥션 í’€ë§ê³¼ ê³µìœ ë¥¼ ì„¤ì •í•œë‹¤. ì´ê²ƒì€ Tomcatì´ (ê·¸ê²ƒì˜ ë¯¸ë¦¬ 빌드ë˜ì–´ 있는 DBCP í’€ë§ íŠ¹ì§•ì„ ì‚¬ìš©í•˜ì—¬) í’€ë§ëœ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì œê³µí• ê²ƒì´ê³ , Hibernateê°€ JNDI를 통해 ì´ë“¤ ì»¤ë„¥ì…˜ë“¤ì„ ìš”ì²í•œë‹¤ëŠ” ê²ƒì„ ì˜ë¯¸í•œë‹¤. 달리 ë‹¹ì‹ ì€ Hibernateë¡œ 하여금 커넥션 í’€ì„ ê´€ë¦¬í•˜ë„ë¡ í• ìˆ˜ 있다. Tomcatì€ ê·¸ê²ƒì˜ ì»¤ë„¥ì…˜ í’€ì„ JNDIì— ë°”ì¸ë“œ 시킨다; 우리는 리소스 ì„ ì–¸ì„ Tomcat ë©”ì¸ êµ¬ì„± 파ì¼ì¸ <literal>TOMCAT/conf/server.xml</literal>ì— ì¶”ê°€í•œë‹¤:"
+
+#: index.docbook:160
+msgid "appended paragraph 27"
+msgstr ""
+ "<![CDATA[<Context path=\"/quickstart\" docBase=\"quickstart\">\n"
+ " <Resource name=\"jdbc/quickstart\" scope=\"Shareable\" type=\"javax.sql.DataSource\"/>\n"
+ " <ResourceParams name=\"jdbc/quickstart\">\n"
+ " <parameter>\n"
+ " <name>factory</name>\n"
+ " <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>\n"
+ " </parameter>\n"
+ "\n"
+ " <!-- DBCP database connection settings -->\n"
+ " <parameter>\n"
+ " <name>url</name>\n"
+ " <value>jdbc:postgresql://localhost/quickstart</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>driverClassName</name><value>org.postgresql.Driver</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>username</name>\n"
+ " <value>quickstart</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>password</name>\n"
+ " <value>secret</value>\n"
+ " </parameter>\n"
+ "\n"
+ " <!-- DBCP connection pooling options -->\n"
+ " <parameter>\n"
+ " <name>maxWait</name>\n"
+ " <value>3000</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>maxIdle</name>\n"
+ " <value>100</value>\n"
+ " </parameter>\n"
+ " <parameter>\n"
+ " <name>maxActive</name>\n"
+ " <value>10</value>\n"
+ " </parameter>\n"
+ " </ResourceParams>\n"
+ "</Context>]]>"
+
+#: index.docbook:162
+msgid "appended paragraph 28"
+msgstr "우리가 ì´ ì˜ˆì œì—ì„œ 구성하는 컨í…스트는 <literal>quickstart</literal>ë¡œ 명명ë˜ê³ , ê·¸ê²ƒì˜ ë² ì´ìŠ¤ëŠ” <literal>TOMCAT/webapp/quickstart</literal> ë””ë ‰í† ë¦¬ì´ë‹¤. ìž„ì˜ì˜ ì„œë¸”ë¦¿ë“¤ì— ì ‘ê·¼í•˜ê¸° 위해, (ë¬¼ë¡ ë‹¹ì‹ ì˜ <literal>web.xml</literal> ì†ì— ë§¤í•‘ëœ ì„œë¸”ë¦¿ì˜ ì´ë¦„ì„ ì¶”ê°€í•˜ì—¬) ë‹¹ì‹ ì˜ ë¸Œë¼ìš°ì €ì—ì„œ <literal>http://localhost:8080/quickstart</literal> 경로를 호출하ë¼. ë‹¹ì‹ ì€ ë˜í•œ ê³„ì† ì§„í–‰í•˜ê³ ì´ì œ ê³µë°±ì˜ <literal>process()</literal> 메소드를 가진 간단한 ì„œë¸”ë¦¿ì„ ìƒì„±ì‹œí‚¬ 수 있다."
+
+#: index.docbook:170
+msgid "appended paragraph 29"
+msgstr "Tomcatì€ ì´ì œ <literal>java:comp/env/jdbc/quickstart</literal>ë¡œ JNDIì„ í†µí•´ ì»¤ë„¥ì…˜ë“¤ì„ ì œê³µí•œë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì‹¤í–‰ ì¤‘ì¸ ì»¤ë„¥ì…˜ í’€ì„ ì–»ëŠ” ê²ƒì— ë¬¸ì œê°€ 있다면 Tomcat 문서를 참조하ë¼. ë‹¹ì‹ ì´ JDBC ë“œë¼ì´ë²„ 예외ìƒí™© 메시지를 ì–»ì„ ê²½ìš°, ë¨¼ì € Hibernate ì—†ì´ JDBC 커넥션 í’€ì„ ì…‹ì—…í•˜ë¼. Tomcat & JDBC íŠœí† ë¦¬ì–¼ë“¤ì€ ê·¸ 웹 ì„œì´íŠ¸ì—ì„œ ì´ìš© 가능하다."
+
+#: index.docbook:177
+msgid "appended paragraph 30"
+msgstr "ë‹¹ì‹ ì˜ ë‹¤ìŒ ë‹¨ê³„ëŠ” Hibernate를 구성하는 것ì´ë‹¤. Hibernate는 ê·¸ê²ƒì´ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì–»ëŠ” ë°©ë²•ì„ ì•Œê³ ìžˆì–´ì•¼ 한다. 우리는 Hibernateì˜ XML 기반 êµ¬ì„±ì„ ì‚¬ìš©í•œë‹¤. properties 파ì¼ì„ 사용하는 다른 ì ‘ê·¼ë²•ì€ ê±°ì˜ ë™ì¼í•˜ì§€ë§Œ XML êµ¬ë¬¸ì´ í—ˆìš©í•˜ëŠ” 몇몇 íŠ¹ì§•ë“¤ì„ ëˆ„ë½í•˜ê³ 있다. XML 구성 파ì¼ì€ <literal>hibernate.cfg.xml</literal>로서 컨í…스트 classpath (<literal>WEB-INF/classes</literal>) ë‚´ì— ìœ„ì¹˜í•´ 있다:"
+
+#: index.docbook:184
+msgid "appended paragraph 31"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <property name=\"connection.datasource\">java:comp/env/jdbc/quickstart</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.PostgreSQLDialect</property>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <mapping resource=\"Cat.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:186
+msgid "appended paragraph 32"
+msgstr "우리는 SQL ëª…ë ¹ë“¤ì— ëŒ€í•œ ë¡œê¹…ì„ ì‚¬ìš©í•˜ì§€ ì•Šê³ Hibernateì—게 사용ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ SQL directê°€ 무엇ì¸ì§€ ê·¸ë¦¬ê³ (Tomcat ë°”ì¸ë“œëœ í’€ì˜ JNDI 주소를 ì„ ì–¸í•˜ì—¬) JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì–»ëŠ” ê³³ì„ ì•Œë ¤ì¤€ë‹¤. dialect는 필수ì ì¸ ì„¤ì •ì´ê³ , ë°ì´í„°ë² ì´ìŠ¤ë“¤ì€ SQL \"표준\"ì— ëŒ€í•œ ê·¸ê²ƒë“¤ì˜ í•´ì„ì„ ë‹¬ë¦¬í•œë‹¤. Hibernate는 ì°¨ì´ì ë“¤ì„ ì²˜ë¦¬í•˜ê³ ëª¨ë“ ì£¼ìš” ìƒìš© ë°ì´í„°ë² ì´ìŠ¤ë“¤ ë° ì˜¤í”ˆ 소스 ë°ì´í„°ë² ì´ìŠ¤ë“¤ ìš©ë„ì˜ directë“¤ì„ ë²ˆë“¤ë¡œ í¬í•¨í•˜ê³ 있다."
+
+#: index.docbook:193
+msgid "appended paragraph 33"
+msgstr "<literal>SessionFactory</literal>는 ë‹¨ì¼ ë°ì´í„°ì €ìž¥ì†Œì— 관한 ê°œë…ì´ê³ , 여러 ë°ì´í„°ë² ì´ìŠ¤ë“¤ì€ 여러 ê°œì˜ XML 구성 파ì¼ë“¤ì„ ìƒì„±ì‹œí‚¤ê³ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì†ì—ì„œ 여러 ê°œì˜ <literal>Configuration</literal> ë° <literal>SessionFactory</literal> ê°ì²´ë“¤ì„ ìƒì„±ì‹œì¼œì„œ 사용ë 수 있다."
+
+#: index.docbook:199
+msgid "appended paragraph 34"
+msgstr "<literal>hibernate.cfg.xml</literal>ì˜ ë§ˆì§€ë§‰ 요소는 ì˜ì† í´ëž˜ìŠ¤ <literal>Cat</literal>ì— ëŒ€í•œ Hibernate XML 매핑 파ì¼ì˜ ì´ë¦„ìœ¼ë¡œì¨ <literal>Cat.hbm.xml</literal>ì„ ì„ ì–¸í•œë‹¤. ì´ íŒŒì¼ì€ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”(ë˜ëŠ” í…Œì´ë¸”들)ë¡œ POJO í´ëž˜ìŠ¤ <literal>Cat</literal> ì„ ë§¤í•‘ì‹œí‚¤ëŠ” 메타ë°ì´í„°ë¥¼ í¬í•¨í•œë‹¤. 우리는 곧 ê·¸ 파ì¼ë¡œ ë˜ëŒì•„ ê°ˆ 것ì´ë‹¤. ë¨¼ì € POJO í´ëž˜ìŠ¤ë¥¼ ìž‘ì„±í•˜ê³ ê·¸ëŸ° ë‹¤ìŒ ê·¸ê²ƒì„ ìœ„í•œ 매핑 메타ë°ì´í„°ë¥¼ ì„ ì–¸í•˜ìž."
+
+#: index.docbook:209
+msgid "appended paragraph 35"
+msgstr "첫 번째 ì˜ì† í´ëž˜ìŠ¤"
+
+#: index.docbook:211
+msgid "appended paragraph 36"
+msgstr "Hibernate는 ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대한 Plain Old Java Objects (POJOs, 종종 Plain Ordinary Java Objectsë¡œ 명명ëœë‹¤) í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ìœ¼ë¡œ 가장 잘 ë™ìž‘한다. POJO는 공용으로 가시ì ì¸ ì¸í„°íŽ˜ì´ìŠ¤ë¡œë¶€í„° 내부ì ì¸ í‘œìƒì„ ì€í시켜, getter와 setter ë©”ì†Œë“œë“¤ì„ í†µí•´ ì ‘ê·¼ê°€ëŠ¥í•œ í´ëž˜ìŠ¤ë“¤ì˜ 프로í¼í‹°ë“¤ì„ 가진 ìžë°”빈과 꽤 ìœ ì‚¬í•˜ë‹¤(필요하다면 Hibernate는 ë˜í•œ í•„ë“œë“¤ì— ì§ì ‘ ì ‘ê·¼í• ìˆ˜ 있다):"
+
+#: index.docbook:218
+msgid "appended paragraph 37"
+msgstr ""
+ "<![CDATA[package org.hibernate.examples.quickstart;\n"
+ "\n"
+ "public class Cat {\n"
+ "\n"
+ " private String id;\n"
+ " private String name;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " public Cat() {\n"
+ " }\n"
+ "\n"
+ " public String getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(String id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ "\n"
+ " public void setName(String name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ "\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " public void setSex(char sex) {\n"
+ " this.sex = sex;\n"
+ " }\n"
+ "\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:220
+msgid "appended paragraph 38"
+msgstr "Hibernate는 ê·¸ê²ƒì˜ í”„ë¡œí¼í‹° íƒ€ìž…ë“¤ì˜ ì‚¬ìš©ì— ì œì•½ë˜ì§€ ì•Šê³ , ìžë°” ì½œë ‰ì…˜ í”„ë ˆìž„ì›ì—ì„œì˜ í´ëž˜ìŠ¤ë“¤ì„ í¬í•¨í•˜ì—¬, ëª¨ë“ ìžë°” JDK 타입들과 (<literal>String</literal>, <literal>char</literal>와 <literal>Date</literal> ê°™ì€) ì›ì‹œíƒ€ìž…ë“¤ì´ ë§¤í•‘ë 수 있다. ë‹¹ì‹ ì€ ê·¸ê²ƒì„ ê°’ë“¤ë¡œì„œ, ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ë“¤ë¡œì„œ, ë˜ëŠ” 다른 ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ 연관들로서 매핑시킬 수 있다. <literal>id</literal>는 ê·¸ í´ëž˜ìŠ¤ì˜ ë°ì´í„°ë² ì´ìŠ¤ ì‹ë³„ìž(프ë¼ì´ë¨¸ë¦¬ 키)를 표현하는 특별한 프로í¼í‹°ì´ê³ , ê·¸ê²ƒì€ <literal>Cat</literal>ê³¼ ê°™ì€ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ 매우 권장ëœë‹¤. Hibernate는 내부ì 으로만 ì‹ë³„ìžë“¤ì„ ì‚¬ìš©í• ìˆ˜ 있지만, 우리는 ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ 아키í…처ì—ì„œ ì–´ë–¤ ìœ ì—°ì„±ì„ ìƒì‹¤í•˜ê²Œ ë 것ì´ë‹¤."
+
+#: index.docbook:229
+msgid "appended paragraph 39"
+msgstr "íŠ¹ì • ì¸í„°íŽ˜ì´ìŠ¤ëŠ” ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대해 구현ë˜ì§€ ë§ì•„야 하거나 íŠ¹ì • 루트 ì˜ì† í´ëž˜ìŠ¤ë¡œë¶€í„° 서브 í´ëž˜ìŠ¤ë¡œ 만들지 ë§ì•„야 한다. Hibernate는 ë˜í•œ ë°”ì´íŠ¸ 코드 처리와 ê°™ì€, ì–´ë–¤ 빌드 ì‹œ 처리를 필요로 하지 ì•Šê³ , ê·¸ê²ƒì€ ì˜¤ì§ ìžë°” reflectionê³¼ (CGLIB를 통한) 런타임 í´ëž˜ìŠ¤ ê³ ì–‘ì—만 ì˜ì¡´í•œë‹¤. ë”°ë¼ì„œ Hibernateì— ëŒ€í•œ POJO í´ëž˜ìŠ¤ì˜ ì–´ë–¤ ì˜ì¡´ì„± ì—†ì´ë„, 우리는 ê·¸ê²ƒì„ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ë¡œ ë§¤í•‘í• ìˆ˜ 있다."
+
+#: index.docbook:239
+msgid "appended paragraph 40"
+msgstr "cat 매핑하기"
+
+#: index.docbook:241
+msgid "appended paragraph 41"
+msgstr "<literal>Cat.hbm.xml</literal> 매핑파ì¼ì€ ê°ì²´/관계형 ë§¤í•‘ì— í•„ìš”í•œ 메타ë°ì´í„°ë¥¼ í¬í•¨í•œë‹¤. 메타ë°ì´í„°ëŠ” ì˜ì† í´ëž˜ìŠ¤ë“¤ì˜ ì„ ì–¸ê³¼ ë°ì´í„°ë² ì´ìŠ¤ í…Œì´ë¸”ë“¤ì— ëŒ€í•œ (컬럼들과 다른 ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ foreign 키 ê´€ê³„ë“¤ì— ëŒ€í•œ) 프로í¼í‹°ë“¤ì˜ ë§¤í•‘ì„ í¬í•¨í•œë‹¤."
+
+#: index.docbook:247
+msgid "appended paragraph 42"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"org.hibernate.examples.quickstart.Cat\" table=\"CAT\">\n"
+ "\n"
+ " <!-- A 32 hex character is our surrogate key. It's automatically\n"
+ " generated by Hibernate with the UUID pattern. -->\n"
+ " <id name=\"id\" type=\"string\" unsaved-value=\"null\" >\n"
+ " <column name=\"CAT_ID\" sql-type=\"char(32)\" not-null=\"true\"/>\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- A cat has to have a name, but it shouldn' be too long. -->\n"
+ " <property name=\"name\">\n"
+ " <column name=\"NAME\" length=\"16\" not-null=\"true\"/>\n"
+ " </property>\n"
+ "\n"
+ " <property name=\"sex\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:249
+msgid "appended paragraph 43"
+msgstr "ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ëŠ” ì‹ë³„ìž ì†ì„±ì„ ê°€ì ¸ì•¼ 한다(ì‹¤ì œë¡œ value-íƒ€ìž…ì˜ í´ëž˜ìŠ¤ë“¤ì— ì˜ì¡´í•˜ì§€ 않는, ì—”í‹°í‹°ë“¤ì„ í‘œí˜„í•˜ëŠ” ìœ ì¼í•œ í´ëž˜ìŠ¤ë“¤ì€ ì—”í‹°í‹°ì„ ê°€ì§„ ì»´í¬ë„ŒíŠ¸ë“¤ë¡œ 매핑ëœë‹¤). ì´ í”„ë¡œí¼í‹°ëŠ” ì˜ì† ê°ì²´ë“¤ì„ êµ¬ë³„ì§“ëŠ”ë° ì‚¬ìš©ëœë‹¤: ë§Œì¼ <literal>catA.getId().equals(catB.getId())</literal>ê°€ trueì¼ ê²½ìš°, ë‘ ê°œì˜ catë“¤ì€ ê°™ê³ , ì´ ê°œë…ì€ <emphasis>database identity</emphasis>ë¡œ 명명ëœë‹¤. Hibernate는 (ë°ì´í„°ë² ì´ìŠ¤ 시퀀스, hi/lo ì‹ë³„ìž í…Œì´ë¸”들, ê·¸ë¦¬ê³ ì–´í”Œë¦¬ì¼€ì´ì…˜ í• ë‹¹ ì‹ë³„ìžë“¤ì— 대한 native ìƒì„±ê¸°ë“¤ì„ í¬í•¨í•˜ëŠ”) 다른 ì‹œë‚˜ë¦¬ì˜¤ë“¤ì— ëŒ€í•´ 여러 가지 ì‹ë³„ìž ìƒì„±ê¸°ë“¤ì„ 번들로 ê°–ê³ ìžˆë‹¤. 우리는 UUID ìƒì„±ê¸°(ë°ì´í„°ì´ìŠ¤ì— ì˜í•´ ìƒì„±ëœ ì •ìˆ˜ 대용 í‚¤ë“¤ì´ ì„ í˜¸ë 것ì´ë¯€ë¡œ, 테스트용으로만 권장ë¨)를 ì‚¬ìš©í•˜ê³ ë˜í•œ Hibernate ìƒì„±ëœ ì‹ë³„ìž ê°’ì„ ìœ„í•œ <literal>CAT</liter!
al> í…Œì´ë¸”ì˜ <literal>CAT_ID</literal> ì»¬ëŸ¼ì„ (í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키로서) ì§€ì •í•œë‹¤."
+
+#: index.docbook:260
+msgid "appended paragraph 44"
+msgstr "<literal>Cat</literal>ì˜ ëª¨ë“ ë‹¤ë¥¸ 프로í¼í‹°ë“¤ì€ ë™ì¼í•œ í…Œì´ë¸”ë¡œ 매핑ëœë‹¤. <literal>name</literal> 프로í¼í‹°ì˜ 경우ì—, 우리는 ê·¸ê²ƒì„ ëª…ì‹œì ì¸ ë°ì´í„°ë² ì´ìŠ¤ 컬럼 ì„ ì–¸ìœ¼ë¡œ 매핑시켰다. ë°ì´í„°ë² ì´ìŠ¤ 스키마가 Hibernateì˜ <emphasis>SchemaExport</emphasis> ë„êµ¬ì— ì˜í•´ 매핑 ì„ ì–¸ìœ¼ë¡œë¶€í„° (SQL DDL 문장들로) ìžë™ì 으로 ìƒì„±ë ë•Œ ì´ê²ƒì´ 특별히 ìœ ìš©í•˜ë‹¤. ëª¨ë“ ë‹¤ë¥¸ 프로í¼í‹°ë“¤ì€ Hibernateì˜ ë””í´íŠ¸ ì„¤ì •ë“¤ì„ ì‚¬ìš©í•˜ì—¬ 매핑ë˜ê³ , ë””í´íŠ¸ ì„¤ì •ë“¤ì€ ë‹¹ì‹ ì´ ê°€ìž¥ ë§Žì€ ì‹œê°„ì„ í•„ìš”ë¡œ 하는 것ì´ë‹¤. ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì˜ í…Œì´ë¸” <literal>CAT</literal>ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:268
+msgid "appended paragraph 45"
+msgstr ""
+ "<![CDATA[ Column | Type | Modifiers\n"
+ "--------+-----------------------+-----------\n"
+ " cat_id | character(32) | not null\n"
+ " name | character varying(16) | not null\n"
+ " sex | character(1) |\n"
+ " weight | real |\n"
+ "Indexes: cat_pkey primary key btree (cat_id)]]>"
+
+#: index.docbook:270
+msgid "appended paragraph 46"
+msgstr "ë‹¹ì‹ ì€ ì´ì œ 수작업으로 ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ì´ í…Œì´ë¸”ì„ ìƒì„±ì‹œí‚¬ 것ì´ê³ , ë§Œì¼ ë‹¹ì‹ ì´ <literal>hbm2ddl</literal> ë„구로 ì´ ë‹¨ê³„ë¥¼ ìžë™í™” ì‹œí‚¤ê³ ìž ì›í• 경우 <xref linkend=\"toolsetguide\"/>를 ì½ì–´ë¼. ì´ ë„구는 í…Œì´ë¸” ì •ì˜, 맞춤형 컬럼 타입 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤, ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ê³¼ ì¸ë±ìŠ¤ë“¤ì„ í¬í•¨í•˜ëŠ”, ì „ì²´ SQL DDLì„ ìƒì„±ì‹œí‚¬ 수 있다."
+
+#: index.docbook:279
+msgid "appended paragraph 47"
+msgstr "catë“¤ì— ìž‘ì—…í•˜ê¸°"
+
+#: index.docbook:281
+msgid "appended paragraph 48"
+msgstr "우리는 ì´ì œ Hibernateì˜ <literal>Session</literal>ì„ ì‹œìž‘í• ì¤€ë¹„ê°€ ë˜ì–´ 있다. ê·¸ê²ƒì€ <emphasis>persistence manager</emphasis> (ì˜ì† 관리ìž)ì´ê³ , 우리는 ë°ì´í„°ë² ì´ìŠ¤ë¡œ <literal>Cat</literal>ë“¤ì„ ì €ìž¥í•˜ê³ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° <literal>Cat</literal>ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° ê·¸ê²ƒì„ ì‚¬ìš©í•œë‹¤. 그러나 ë¨¼ì € 우리는 <literal>SessionFactory</literal>로부터 <literal>Session</literal>(Hibernateì˜ ìž‘ì—… 단위)를 얻어야 한다:"
+
+#: index.docbook:288
+msgid "appended paragraph 49"
+msgstr ""
+ "<![CDATA[SessionFactory sessionFactory =\n"
+ " new Configuration().configure().buildSessionFactory();]]>"
+
+#: index.docbook:290
+msgid "appended paragraph 50"
+msgstr "<literal>configure()</literal> í˜¸ì¶œì€ <literal>hibernate.cfg.xml</literal> 구성 파ì¼ì„ ë¡œë“œì‹œí‚¤ê³ <literal>Configuration</literal> ì¸ìŠ¤í„´ìŠ¤ë¥¼ 초기화 시킨다. ë‹¹ì‹ ì´ SessionFactory(불변ì ìž„)를 빌드하기 <emphasis>ì´ì „ì—</emphasis> ë‹¹ì‹ ì€ <literal>Configuration</literal>ì— ì ‘ê·¼í•¨ìœ¼ë¡œì¨ ë‹¤ë¥¸ 프로í¼í‹°ë“¤ì„ ì„¤ì •í• ìˆ˜ 있다(ê·¸ë¦¬ê³ ì‹¬ì§€ì–´ 매핑 메타ë°ì´í„°ë¥¼ 변경시킬 수 있다). 우리는 어디서 <literal>SessionFactory</literal>를 ìƒì„±ì‹œí‚¤ê³ ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì†ì—ì„œ 어떻게 ê·¸ê²ƒì— ì ‘ê·¼í• ìˆ˜ 있나?"
+
+#: index.docbook:298
+msgid "appended paragraph 51"
+msgstr "<literal>SessionFactory</literal>는 대개 ì˜¤ì§ í•œë²ˆë§Œ, 예를 들어 대개 <emphasis>load-on-startup</emphasis> 서블릿으로 시작 ì‹œì— ë¹Œë“œëœë‹¤. ì´ê²ƒì€ ë˜í•œ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ì„œë¸”ë¦¿ë“¤ ë‚´ì— ìžˆëŠ” ì¸ìŠ¤í„´ìŠ¤ 변수 ì†ì— ê·¸ê²ƒì„ ìœ ì§€í•˜ì§€ ì•Šì„ ê²ƒì´ì§€ë§Œ ì–´ë–¤ 다른 ìœ„ì¹˜ì— ìœ ì§€ì‹œí‚¬ ê²ƒìž„ì„ ì˜ë¯¸í•œë‹¤. ë”구나 우리는 ì–´ë–¤ ì¢…ë¥˜ì˜ <emphasis>Singleton</emphasis>ì„ í•„ìš”ë¡œ 하며, ë”°ë¼ì„œ 우리는 어플리케ì´ì…˜ 코드로 쉽게 <literal>SessionFactory</literal>ì— ì•¡ì„¸ìŠ¤ í• ìˆ˜ 있다. 다ìŒì— 보여진 ì ‘ê·¼ë²•ì€ ë‘ ë¬¸ì œ 모ë‘를 해결한다: 시작 구성과 <literal>SessionFactory</literal>ì— ëŒ€í•œ 쉬운 ì ‘ê·¼."
+
+#: index.docbook:306
+msgid "appended paragraph 52"
+msgstr "우리는 <literal>HibernateUtil</literal> helper í´ëž˜ìŠ¤ë¥¼ 구현한다:"
+
+#: index.docbook:310
+msgid "appended paragraph 53"
+msgstr ""
+ "<![CDATA[import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static Logger log = LoggerFactory.getLogger(HibernateUtil.class);\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " log.error(\"Initial SessionFactory creation failed.\", ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static final ThreadLocal session = new ThreadLocal();\n"
+ "\n"
+ " public static Session getCurrentSession() {\n"
+ " Session s = (Session) session.get();\n"
+ " // Open a new Session, if this Thread has none yet\n"
+ " if (s == null) {\n"
+ " s = sessionFactory.openSession();\n"
+ " session.set(s);\n"
+ " }\n"
+ " return s;\n"
+ " }\n"
+ "\n"
+ " public static void closeSession() {\n"
+ " Session s = (Session) session.get();\n"
+ " if (s != null)\n"
+ " s.close();\n"
+ " session.set(null);\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:312
+msgid "appended paragraph 54"
+msgstr "ì´ í´ëž˜ìŠ¤ëŠ” static 초기ìžë¥¼ 가진 <literal>SessionFactory</literal>를 ì²˜ë¦¬í• ë¿ë§Œ ì•„ë‹ˆë¼ ë˜í•œ í˜„ìž¬ì˜ ì“°ë ˆë“œë¥¼ 위한 <literal>Session</literal>ì„ ì†Œìœ í•˜ëŠ” <literal>ThreadLocal</literal> 변수를 갖는다. ì´ helper를 ì‚¬ìš©í•˜ë ¤ê³ ì‹œë„하기 ì „ì— thread-local ë³€ìˆ˜ì— ëŒ€í•œ ìžë°” ê°œë…ì„ ì´í•´í•´ì•¼ 한다. 보다 ë³µìž¡í•˜ê³ ê°•ë ¥í•œ <literal>HibernateUtil</literal> í´ëž˜ìŠ¤ëŠ” http://caveatemptor.hibernate.org/ì˜ <literal>CaveatEmptor</literal>ì—ì„œ ì°¾ì„ ìˆ˜ 있다."
+
+#: index.docbook:319
+msgid "appended paragraph 55"
+msgstr "<literal>SessionFactory</literal>는 threadsafeì´ê³ , ë§Žì€ ì“°ë ˆë“œë“¤ì´ ë™ì‹œì— ê·¸ê²ƒì— ì ‘ê·¼í• ìˆ˜ ìžˆê³ <literal>Session</literal>ë“¤ì„ ìš”ì²í• 수 있다. í•˜ë‚˜ì˜ <literal>Session</literal>ì€ ë°ì´í„°ë² ì´ìŠ¤ì— 대해 í•œ ê°œì˜ ë‹¨ìœ„ ìž‘ì—…ì„ ë‚˜íƒ€ë‚´ëŠ” non-threadsafe ê°ì²´ì´ë‹¤. <literal>Session</literal>ë“¤ì€ <literal>SessionFactory</literal> 로부터 ì—´ë ¤ì§€ê³ ëª¨ë“ ìž‘ì—…ì´ ì™„ë£Œë ë•Œ 닫혀진다. ë‹¹ì‹ ì˜ ì„œë¸”ë¦¿ì˜ <literal>process()</literal> 메소드 ë‚´ì— ìžˆëŠ” ì˜ˆì œëŠ” 다ìŒê³¼ ê°™ì„ ìˆ˜ 있다(예외ìƒí™© 처리 ì—†ì´):"
+
+#: index.docbook:327
+msgid "appended paragraph 56"
+msgstr ""
+ "<![CDATA[Session session = HibernateUtil.getCurrentSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Cat princess = new Cat();\n"
+ "princess.setName(\"Princess\");\n"
+ "princess.setSex('F');\n"
+ "princess.setWeight(7.4f);\n"
+ "\n"
+ "session.save(princess);\n"
+ "\n"
+ "tx.commit();\n"
+ "HibernateUtil.closeSession();]]>"
+
+#: index.docbook:329
+msgid "appended paragraph 57"
+msgstr "í•˜ë‚˜ì˜ <literal>Session</literal> ë‚´ì—ì„œ ëª¨ë“ ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ì€ ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ë“¤(심지어 ì½ê¸° ì „ìš© 오í¼ë ˆì´ì…˜ë“¤ ì¡°ì°¨ë„)ì„ ê²©ë¦¬ì‹œí‚¤ëŠ” í•˜ë‚˜ì˜ íŠ¸ëžœìžì…˜ 내부ì—ì„œ ë°œìƒí•œë‹¤. 우리는 기본 트랜ìžì…˜ ë°©ë„(ìš°ë¦¬ì˜ ê²½ìš°, JDBC 트랜ìžì…˜ë“¤)로부터 추ìƒí™”ì‹œí‚¤ëŠ”ë° Hibernates <literal>Transaction</literal> API 를 사용한다. ì´ê²ƒì€ ìš°ë¦¬ì˜ ì½”ë“œê°€ ìž„ì˜ì˜ 변경들 ì—†ì´ë„ (JTA를 사용하는) 컨테ì´ë„ˆ-관리ë˜ëŠ” 트랜ìžì…˜ë“¤ì— 배치ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:336
+msgid "appended paragraph 58"
+msgstr "ë‹¹ì‹ ì´ ì›í•˜ëŠ” ë§Œí¼ ë‹¹ì‹ ì´ <literal>HibernateUtil.getCurrentSession();</literal>ì„ í˜¸ì¶œí• ìˆ˜ ìžˆê³ , ë‹¹ì‹ ì€ ì´ ì“°ë ˆë“œì˜ í˜„ìž¬ <literal>Session</literal>ì„ í•ìƒ ì–»ì„ ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼. ë‹¹ì‹ ì€ ì„œë¸”ë¦¿ 코드 ë‚´ì—ì„œë“ ë˜ëŠ” 서블릿 í•„í„° ë‚´ì—ì„œë“ HTTP responseê°€ ì „ì†¡ë˜ê¸° ì „ì—, ë‹¹ì‹ ì˜ ë‹¨ìœ„ ìž‘ì—…ì´ ì™„ë£Œëœ í›„ì— <literal>Session</literal>ì´ í™•ì‹¤ížˆ 닫혀지ë„ë¡ í•´ì•¼ 한다. ë‘ ë²ˆì§¸ ì˜µì…˜ì˜ ì¢‹ì€ ì¸¡ë©´ì€ ì‰¬ìš´ lazy 초기화ì´ë‹¤: ë·°ê°€ ë Œë”ë§ ë ë•Œ <literal>Session</literal>ì´ ì—¬ì „ížˆ ì—´ë ¤ì ¸ 있어서, Hibernate는 ë‹¹ì‹ ì´ í˜„ìž¬ ê°ì²´ 그래프를 네비게ì´íŠ¸ 하는 ë™ì•ˆ 초기화 ë˜ì§€ ì•Šì€ ê°ì²´ë“¤ì„ 로드시킬 수 있다."
+
+#: index.docbook:344
+msgid "appended paragraph 59"
+msgstr "Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ê°ì²´ë“¤ì„ ê²€ìƒ‰í•˜ëŠ”ë° ì‚¬ìš©ë 수 있는 다양한 ë©”ì†Œë“œë“¤ì„ ê°–ê³ ìžˆë‹¤. 가장 ìœ ì—°í•œ ë°©ë²•ì€ Hibernate Query Language (HQL)ì„ ì‚¬ìš©í•˜ëŠ” 것ì´ë‹¤. Hibernate Query Language (HQL)ì€ ë°°ìš°ê¸°ê°€ ì‰½ê³ SQLì— ëŒ€í•œ ê°•ë ¥í•œ ê°ì²´ 지향 확장ì´ë‹¤:"
+
+#: index.docbook:350
+msgid "appended paragraph 60"
+msgstr ""
+ "<![CDATA[Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Query query = session.createQuery(\"select c from Cat as c where c.sex = :sex\");\n"
+ "query.setCharacter(\"sex\", 'F');\n"
+ "for (Iterator it = query.iterate(); it.hasNext();) {\n"
+ " Cat cat = (Cat) it.next();\n"
+ " out.println(\"Female Cat: \" + cat.getName() );\n"
+ "}\n"
+ "\n"
+ "tx.commit();]]>"
+
+#: index.docbook:352
+msgid "appended paragraph 61"
+msgstr "Hibernate는 ë˜í•œ type-safe 질ì˜ë“¤ì„ ê³µì‹í™” ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë 수 있는 ê°ì²´-지향 <emphasis>query by criteria</emphasis> APIì„ ì œê³µí•œë‹¤. ë¬¼ë¡ Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ì™€ì˜ ëª¨ë“ SQL í†µì‹ ì„ ìœ„í•´ <literal>PreparedStatement</literal>들과 파ë¼ë¯¸í„° ë°”ì¸ë”©ì„ 사용한다. ë‹¹ì‹ ì€ ë˜í•œ Hibernate ì§ì ‘ì ì¸ SQL ì§ˆì˜ íŠ¹ì§•ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆê±°ë‚˜ 드문 ê²½ìš°ì— <literal>Session</literal>으로부터 plain JDBC ì»¤ë„¥ì…˜ì„ ì–»ì„ ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:362
+msgid "appended paragraph 62"
+msgstr "마지막으로"
+
+#: index.docbook:364
+msgid "appended paragraph 63"
+msgstr "우리는 ì´ ìž‘ì€ íŠœí† ë¦¬ì–¼ ë‚´ì—ì„œ 단지 Hibernateì˜ í‘œë©´ì„ í›‘ê¸°ë§Œ 했다. 우리는 ìš°ë¦¬ì˜ ì˜ˆì œë“¤ ì†ì— ì–´ë–¤ 서블릿 ì§€ì •ì 코드를 í¬í•¨í•˜ì§€ ì•ŠìŒì„ 노트하ë¼. ë‹¹ì‹ ì´ ì 합한지를 ì•Œë ¤ê³ í• ë•Œ ë‹¹ì‹ ì€ ë‹¹ì‹ ìžì‹ ì˜ ì„œë¸”ë¦¿ì„ ìƒì„±ì‹œì¼œì•¼ í•˜ê³ Hibernate 코드를 삽입해야 한다."
+
+#: index.docbook:370
+msgid "appended paragraph 64"
+msgstr "ë°ì´í„° ì ‘ê·¼ 계층으로서 Hibernate는 ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— 강하게 통합ë¨ì„ ì—¼ë‘ì— ë‘ë¼. 대개 ëª¨ë“ ë‹¤ë¥¸ ë ˆì´ì–´ë“¤ì€ ì˜ì† ë©”ì»¤ë‹ˆì¦˜ì— ì˜ì¡´í–ˆë‹¤. ë‹¹ì‹ ì€ ì´ ì„¤ê³„ì˜ í•¨ì¶•ì„ í™•ì‹¤ížˆ ì´í•´í•˜ë„ë¡ í•˜ë¼."
+
+#: index.docbook:375
+msgid "appended paragraph 65"
+msgstr "보다 복잡한 어플리케ì´ì…˜ ì˜ˆì œëŠ” http://caveatemptor.hibernate.org/ 를 ë³´ê³ http://caveatemptor.hibernate.org/ì— ìžˆëŠ” 다른 íŠœí† ë¦¬ì–¼ë“¤ì„ ì‚´íŽ´ë³´ë¼."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1225 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr "ê°ì²´ë“¤ë¡œ 작업하기"
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr "Hibernate는 기본 ë°ì´í„°ë² ì´ìŠ¤ 관리 ì‹œìŠ¤í…œì˜ ìƒì„¸ë¡œë¶€í„° 개발ìžë“¤ì„ ì€í시켜줄 ë¿ë§Œ 아니ë¼, ë˜í•œ ê°ì²´ë“¤ì— 대한 <emphasis>ìƒíƒœ 관리</emphasis>를 ì œê³µí•˜ëŠ” í•˜ë‚˜ì˜ ì™„ì „í•œ ê°ì²´/관계형 매핑 솔루션ì´ë‹¤. ì´ê²ƒì€ 공통ì ì¸ JDBC/SQL ì˜ì† 계층들 ë‚´ì—ì„œì˜ SQL <literal>문장들</literal>ì— ëŒ€í•œ 관리와는 반대로, ìžë°” 어플리케ì´ì…˜ë“¤ì—ì„œ ì˜ì†ì— 관한 매우 ê³ ìœ í•œ ê°ì²´-지향ì ê´€ì ì´ë‹¤."
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr "달리 ë§í•´, Hibernate 어플리케ì´ì…˜ 개발ìžë“¤ì€ ê·¸ë“¤ì˜ ê°ì²´ë“¤ì˜ <emphasis>ìƒíƒœ</emphasis>ì— ëŒ€í•´ í•ìƒ ìƒê°í•´ì•¼ í•˜ê³ , SQL ë¬¸ìž¥ë“¤ì˜ ì‹¤í–‰ì— ëŒ€í•´ì„œëŠ” 필수ì ì´ì§€ 않다. ì´ ë¶€ë¶„ì€ Hibernateì— ì˜í•´ 처리ë˜ê³ ì‹œìŠ¤í…œì˜ í¼í¬ë¨¼ìŠ¤ë¥¼ 튜ë‹í• ë•Œ 어플리케ì´ì…˜ 개발ìžì™€ ìœ ì¼í•˜ê²Œ ê´€ë ¨ëœë‹¤."
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr "Hibernate ê°ì²´ ìƒíƒœë“¤"
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr "Hibernate ë‹¤ìŒ ê°ì²´ ìƒíƒœë“¤ì„ ì •ì˜í•˜ê³ 지ì›í•œë‹¤:"
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr "<emphasis>Transient</emphasis> - ë§Œì¼ ê°ì²´ê°€ <literal>new</literal> ì—°ì‚°ìžë¥¼ 사용하여 방금 초기화 ë˜ì—ˆë‹¤ë©´ ê°ì²´ëŠ” transientì´ê³ , ê·¸ê²ƒì€ Hibernate <literal>Session</literal>ê³¼ ì—°ê´€ë˜ì–´ 있지 않다. ê·¸ê²ƒì€ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ ì˜ì† í‘œìƒì„ 갖지 ì•Šê³ ì‹ë³„ìž ê°’ì´ í• ë‹¹ë˜ì§€ 않았다. ë§Œì¼ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ë” ì´ìƒ 참조를 ì†Œìœ í•˜ì§€ ì•Šì„ ê²½ìš° transient ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ì“°ë ˆê¸° ìˆ˜ì§‘ê¸°ì— ì˜í•´ 파괴ë 것ì´ë‹¤. ê°ì²´ë¥¼ ì˜ì†í™” ì‹œí‚¤ëŠ”ë° (ê·¸ë¦¬ê³ ì´ ì „ì´(transition)ì— ëŒ€í•´ 실행ë 필요가 있는 SQL ë¬¸ìž¥ë“¤ì„ Hibernateë¡œ 하여금 처리하ë„ë¡ í•˜ëŠ”ë°) Hibernate <literal>Session</literal>ì„ ì‚¬ìš©í•˜ë¼."
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr "<emphasis>Persistent</emphasis> - í•˜ë‚˜ì˜ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ëŠ” ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ í•˜ë‚˜ì˜ í‘œìƒì„ ê°–ê³ í•˜ë‚˜ì˜ ì‹ë³„ìž ê°’ì„ ê°–ëŠ”ë‹¤. ê·¸ê²ƒì€ ë°©ê¸ˆ ì €ìž¥ë˜ì—ˆê±°ë‚˜ 로드ë˜ì—ˆì„ 수 있지만, ì •ì˜ìƒ ê·¸ê²ƒì€ <literal>Session</literal>ì˜ ë²”ìœ„ ë‚´ì— ìžˆë‹¤. Hibernate는 ì˜ì† ìƒíƒœì—ì„œ ê°ì²´ì— 대해 행해진 ìž„ì˜ì˜ ë³€ê²½ë“¤ì„ ê²€ì¶œí•´ë‚¼ 것ì´ê³ 단위 ìž‘ì—…ì´ ì™„ë£Œë ë•Œ ê·¸ ìƒíƒœë¥¼ ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ê¸°í™” 시킬 것ì´ë‹¤. 개발ìžë“¤ì€ í•˜ë‚˜ì˜ ê°ì²´ê°€ transientë¡œ ë˜ì–´ì•¼ í• ë•Œ <literal>UPDATE</literal> 문장들ì´ë‚˜ <literal>DELETE</literal> ë¬¸ìž¥ë“¤ì„ ìˆ˜ìž‘ì—…ìœ¼ë¡œ 실행하지 않는다."
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr "<emphasis>Detached</emphasis> - í•˜ë‚˜ì˜ detached ì¸ìŠ¤í„´ìŠ¤ëŠ” ì˜ì†í™” ë˜ì—ˆì§€ë§Œ, ê·¸ê²ƒì˜ <literal>Session</literal>ì´ ë‹«í˜€ì§„ ê°ì²´ì´ë‹¤. ë¬¼ë¡ ê·¸ ê°ì²´ì— 대한 참조는 ì—¬ì „ížˆ ìœ íš¨í•˜ê³ , ê·¸ detached ì¸ìŠ¤í„´ìŠ¤ëŠ” ì´ ìƒíƒœì—ì„œë„ ë³€ê²½ë ìˆ˜ë„ ìžˆë‹¤. í•˜ë‚˜ì˜ detached ì¸ìŠ¤í„´ìŠ¤ëŠ” ë‚˜ì¤‘ì— ê·¸ê²ƒ(ê³¼ ëª¨ë‘ ë³€ê²½ë“¤)ì„ ë‹¤ì‹œ ì˜ì†í™” 시켜서 새로운 <literal>Session</literal>ì— ë‹¤ì‹œ 첨부ë 수 있다. ì´ íŠ¹ì§•ì€ ì‚¬ìš©ìžê°€ ìƒê°í• ì‹œê°„ì„ í•„ìš”ë¡œ 하는 장 기간 실행ë˜ëŠ” ìž‘ì—… 단위를 위한 í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ì„ ê°€ëŠ¥í•˜ê²Œ 해준다. 우리는 ê·¸ê²ƒë“¤ì„ <emphasis>어플리케ì´ì…˜ 트랜ìžì…˜ë“¤</emphasis>, 즉 사용ìžì˜ ê´€ì ì˜ ìž‘ì—… 단위ë¼ê³ 부른다."
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr "ì´ì œ 우리는 ìƒíƒœë“¤ê³¼ ìƒíƒœ ì „ì´(transition)들(ê·¸ë¦¬ê³ ì „ì´ë¥¼ 트리거 시키는 Hibernate 메소드들)ì„ ìƒì„¸í•˜ê²Œ ë…¼ì˜í• 것ì´ë‹¤."
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr "ê°ì²´ë“¤ì„ ì˜ì†í™” 시키기"
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr "í•˜ë‚˜ì˜ ì˜ì† í´ëž˜ìŠ¤ì˜ ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ Hibernateì— ì˜í•´ <emphasis>transient</emphasis>ë¡œ 간주ëœë‹¤. 우리는 ê·¸ê²ƒì„ ì„¸ì…˜ê³¼ 연관지어서 transient ì¸ìŠ¤í„´ìŠ¤ë¥¼ <emphasis>ì˜ì†í™”</emphasis> 시킬 수 있다:"
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr "ë§Œì¼ <literal>Cat</literal>ì´ ìƒì„±ëœ ì‹ë³„ìžë¥¼ 가질 경우, <literal>save()</literal>ê°€ 호출ë ë•Œ ê·¸ ì‹ë³„ìžê°€ ìƒì„±ë˜ê³ <literal>cat</literal>ì— í• ë‹¹ëœë‹¤. ë§Œì¼ <literal>Cat</literal>ì´ í•˜ë‚˜ì˜ <literal>assigned</literal> ì‹ë³„ìžë‚˜ í•˜ë‚˜ì˜ composite key를 가질 경우, <literal>save()</literal>를 호출하기 ì „ì— ê·¸ ì‹ë³„ìžê°€<literal>cat</literal> ì¸ìŠ¤í„´ìŠ¤ì— í• ë‹¹ë 것ì´ë‹¤. ë‹¹ì‹ ì€ ë˜í•œ EJB3 초기 드래프트ì—ì„œ ì •ì˜ëœ ì˜ë¯¸ë¡œ <literal>save()</literal> ëŒ€ì‹ <literal>persist()</literal>를 ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr "다른 방법으로, ë‹¹ì‹ ì€ <literal>save()</literal>ì˜ ì˜¤ë²„ë¡œë“œëœ ë²„ì „ì„ ì‚¬ìš©í•˜ì—¬ ì‹ë³„ìžë¥¼ í• ë‹¹í• ìˆ˜ 있다."
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ì˜ì†í™” 시키는 ê°ì²´ê°€ ì—°ê´€ëœ ê°ì²´ë“¤(예를 들면. ì•žì˜ ì˜ˆì œì— ìžˆëŠ” <literal>kittens</literal> ì½œë ‰ì…˜)ì„ ê°–ê³ ìžˆë‹¤ë©´, ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ foreign 키 ì»¬ëŸ¼ì— ëŒ€í•´ í•˜ë‚˜ì˜ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ 갖지 않는 í•œ, ì´ë“¤ ê°ì²´ë“¤ì€ ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ìž„ì˜ì˜ 순서로 ì˜ì†í™” ë˜ì—ˆì„ ìˆ˜ë„ ìžˆë‹¤. foreign 키 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤ì„ 위배하는 ìœ„í—˜ì„±ì´ ê²°ì½” 존재하지 않는다. 하지만 ë‹¹ì‹ ì´ ìž˜ëª»ëœ ìˆœì„œë¡œ ê·¸ ê°ì²´ë“¤ì„ <literal>save()</literal> 시킬 경우 ë‹¹ì‹ ì€ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìœ„ë°°í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr "ë‹¹ì‹ ì´ ì—°ê´€ëœ ê°ì²´ë“¤ì„ ìžë™ì 으로 ì €ìž¥ì‹œí‚¤ëŠ”ë° Hibernateì˜ <emphasis>transitive persistence(ì „ì´ ì˜ì†)</emphasis> íŠ¹ì§•ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ë§¤ìš° ì¢‹ì•„í• ê²ƒì´ë¯€ë¡œ 대개 ë‹¹ì‹ ì€ ì´ ìƒì„¸ë¥¼ ë‚´ë²„ë ¤ë‘”ë‹¤. 그때 <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ ìœ„ë°°ë“¤ì´ ë°œìƒë˜ì§€ ì•Šì„지ë¼ë„ - Hibernate는 ëª¨ë“ ê²ƒì„ ì²˜ë¦¬í• ê²ƒì´ë‹¤. Transitive persistence(ì „ì´ ì˜ì†)ì€ ì´ ìž¥ì—ì„œ 후반부ì—ì„œ ë…¼ì˜ëœë‹¤."
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr "ê°ì²´ë¥¼ 로드시키기"
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr "<literal>Session</literal>ì˜ <literal>load()</literal> ë©”ì†Œë“œë“¤ì€ ë§Œì¼ ë‹¹ì‹ ì´ ê·¸ê²ƒ(ì˜ì† ì¸ìŠ¤í„´ìŠ¤)ì˜ ì‹ë³„ìžë“¤ì„ ì´ë¯¸ ì•Œê³ ìžˆì„ ê²½ìš°ì— ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë¥¼ 검색하는 ë°©ë²•ì„ ë‹¹ì‹ ì—게 ì œê³µí•œë‹¤. <literal>load()</literal>는 í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ ê°ì²´ë¥¼ ì·¨í•˜ê³ ê·¸ ìƒíƒœë¥¼ ì˜ì†(persistent) ìƒíƒœë¡œ ê·¸ í´ëž˜ìŠ¤ì˜ ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ ì¸ìŠ¤í„´ìŠ¤ ì†ìœ¼ë¡œ 로드시킬 것ì´ë‹¤."
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr "다른 방법으로 ë‹¹ì‹ ì€ ì£¼ì–´ì§„ ì¸ìŠ¤í„´ìŠ¤ ì†ìœ¼ë¡œ ìƒíƒœë¥¼ 로드시킬 수 있다:"
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr "ë§Œì¼ ì¼ì¹˜í•˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ í–‰ì´ ì¡´ìž¬í•˜ì§€ ì•Šì„ ê²½ìš°ì— <literal>load()</literal>ê°€ unrecoverable(복구 불가능한) 예외ìƒí™©ì„ ë˜ì§ˆ ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼. ë§Œì¼ í´ëž˜ìŠ¤ê°€ 프ë½ì‹œë¥¼ ê°–ë„ë¡ ë§¤í•‘ëœ ê²½ìš°, <literal>load()</literal>는 초기화 ë˜ì§€ ì•Šì€ í”„ë½ì‹œë¥¼ 단지 ë°˜í™˜í•˜ê³ ë‹¹ì‹ ì´ ê·¸ 프ë½ì‹œì˜ 메소드를 호출하기 ì „ê¹Œì§€ëŠ” ì‹¤ì œë¡œ ë°ì´í„°ë² ì´ìŠ¤ì— ì ‘ì†í•˜ì§€ 않는다. ë‹¹ì‹ ì´ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ê°ì²´ì— 대한 ì—°ê´€ì„ ì‹¤ì œë¡œ 로드시키지 ì•Šê³ ì„œ ê°ì²´ì— 대한 ì—°ê´€ì„ ìƒì„±ì‹œí‚¤ê³ ìž ì›í• ê²½ìš°ì— ì´ íŠ¹ì§•ì´ ë§¤ìš° ìœ ìš©í•˜ë‹¤. ë§Œì¼ <literal>batch-size</literal>ê°€ class ë§¤í•‘ì— ì •ì˜ë˜ëŠ” 경우 ê·¸ê²ƒì€ ë˜í•œ 다중 ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ í•˜ë‚˜ì˜ ë°°ì¹˜ë¡œì„œ 로드ë˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì¤€ë‹¤."
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ ì¼ì¹˜í•˜ëŠ” í–‰ì´ ì¡´ìž¬í•˜ëŠ”ì§€ë¥¼ í™•ì‹ í• ìˆ˜ ì—†ì„ ê²½ìš°, ë‹¹ì‹ ì€ <literal>get()</literal> 메소드를 사용해야 한다. 그것(<literal>get()</literal> 메소드)는 ë°ì´í„°ë² ì´ìŠ¤ì— 즉시 ì ‘ì†í•˜ê³ ë§Œì¼ ì¼ì¹˜í•˜ëŠ” í–‰ì´ ì—†ì„ ê²½ìš° nullì„ ë°˜í™˜í•œë‹¤."
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr "ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ <literal>LockMode</literal>를 사용하는, <literal>SELECT ... FOR UPDATE</literal>를 사용하여 í•˜ë‚˜ì˜ ê°ì²´ë¥¼ 로드시킬 ìˆ˜ë„ ìžˆë‹¤. 추가 ì •ë³´ëŠ” API 문서를 ë³´ë¼."
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr "ì–´ë–¤ ì—°ê´€ëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ë‚˜ í¬í•¨ëœ ì½œë ‰ì…˜ë“¤ì€ ë‹¹ì‹ ì´ ê·¸ ì—°ê´€ì— ëŒ€í•œ 케스케ì´ë“œ 스타ì¼ë¡œì„œ <literal>lock</literal> ë˜ëŠ” <literal>all</literal>ì„ ì§€ì •í•˜ë„ë¡ ê²°ì •í•˜ì§€ 않는 í•œ, <literal>FOR UPDATE</literal>ë¡œ ì„ íƒë˜ì§€ ì•ŠìŒì„ 노트하ë¼."
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr "<literal>refresh()</literal> 메소드를 사용하여, 아무때나 í•˜ë‚˜ì˜ ê°ì²´ì™€ ëª¨ë“ ê·¸ê²ƒì˜ ì½œë ‰ì…˜ë“¤ì„ ë‹¤ì‹œ 로드시키는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. ë°ì´í„°ë² ì´ìŠ¤ íŠ¸ë¦¬ê±°ë“¤ì´ ê·¸ ê°ì²´ì˜ 프로í¼í‹°ë“¤ 중 ì–´ë–¤ ê²ƒì„ ì´ˆê¸°í™” ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë ë•Œ ì´ê²ƒì´ ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr "중요한 ì§ˆë¬¸ì´ ëŒ€ê°œ ì´ ì§€ì ì—ì„œ 나타난다: Hibernate는 ë°ì´í„°ë² ì´ë¡œë¶€í„° ê·¸ê²ƒì„ ì–¼ë§ˆë‚˜ ë§Žì´ ë¡œë“œì‹œí‚¤ê³ ê·¸ë¦¬ê³ ì–¼ë§ˆë‚˜ ë§Žì€ SQL <literal>SELECT</literal>ë“¤ì´ ê·¸ê²ƒì„ ì‚¬ìš©í• ê²ƒì¸ê°€? ì´ê²ƒì€ <emphasis>íŽ˜ì¹ ë°©ë„</emphasis>ì— ì˜ì¡´í•˜ê³ <xref linkend=\"performance-fetching\"/>ì— ì„¤ëª…ë˜ì–´ 있다."
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr "질ì˜í•˜ê¸°"
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì´ ì°¾ê³ ìžˆëŠ” ê°ì²´ë“¤ì— 대한 ì‹ë³„ìžë“¤ì„ 모를 경우, ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ì§ˆì˜ë¥¼ 필요로 한다. Hibernate는 ì‚¬ìš©ì´ ì‰½ì§€ë§Œ ê°•ë ¥í•œ ê°ì²´ 지향 ì§ˆì˜ ì–¸ì–´(HQL)를 지ì›í•œë‹¤. 프로그램 ìƒì˜ ì§ˆì˜ ìƒì„±ì„ 위해, Hibernate는 ì •êµí•œ Criteria ë° Example ì§ˆì˜ íŠ¹ì§•(QBC와 QBE)를 지ì›í•œë‹¤. ë‹¹ì‹ ì€ ë˜í•œ ê°ì²´ë“¤ë¡œì˜ ê²°ê³¼ ì…‹ ë³€í™˜ì„ ìœ„í•œ ì„ íƒì ì¸ Hibernateì˜ ì§€ì›ìœ¼ë¡œ, ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ì˜ native SQL ì†ì— ë‹¹ì‹ ì˜ ì§ˆì˜ë¥¼ í‘œí˜„í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:219
+msgid "Querying"
+msgstr "질ì˜ë“¤ì„ 실행하기"
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr "HQL 질ì˜ì™€ native SQL 질ì˜ëŠ” <literal>org.hibernate.Query</literal>ì˜ ì¸ìŠ¤í„´ìŠ¤ë¡œ 표현ëœë‹¤. ì´ ì¸í„°íŽ˜ì´ìŠ¤ëŠ” 파ë¼ë¯¸í„° ë°”ì¸ë”©, 결과셋 핸들ë§ì„ 위한, ê·¸ë¦¬ê³ ì‹¤ì œ 질ì˜ì˜ ì‹¤í–‰ì„ ìœ„í•œ ë©”ì†Œë“œë“¤ì„ ì œê³µí•œë‹¤. ë‹¹ì‹ ì€ í•ìƒ 현재 <literal>Session</literal>ì„ ì‚¬ìš©í•˜ì—¬ í•˜ë‚˜ì˜ <literal>Query</literal>를 얻는다:"
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr "í•˜ë‚˜ì˜ ì§ˆì˜ëŠ” 대개 <literal>list()</literal>를 호출하여 실행ë˜ê³ , 질ì˜ì˜ 결과는 메모리 ë‚´ì—ì„œ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ ì†ìœ¼ë¡œ ì „ì²´ì 으로 로드ë 것ì´ë‹¤. í•˜ë‚˜ì˜ ì§ˆì˜ì— ì˜í•´ ê²€ìƒ‰ëœ ì—”í‹°í‹° ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ì˜ì†(persistent) ìƒíƒœì— 있다. ë‹¹ì‹ ì˜ ì§ˆì˜ê°€ í•˜ë‚˜ì˜ ê°ì²´ë¥¼ ì˜¤ì§ ë°˜í™˜í• ê²ƒìž„ì„ ë‹¹ì‹ ì´ ì•Œê³ ìžˆì„ ê²½ìš°ì— <literal>uniqueResult()</literal> 메소드는 ë‹¨ì¶•ì„ ì œê³µí•œë‹¤. ì½œë ‰ì…˜ë“¤ì— ëŒ€í•´ eager 페ì¹ì„ 사용하는 질ì˜ë“¤ì€ 대개 (ê·¸ê²ƒë“¤ì˜ ì´ˆê¸°í™”ëœ ì½œë ‰ì…˜ë“¤ì„ ê°€ì§„) 루트 ê°ì²´ë“¤ì— 대한 ì¤‘ë³µë“¤ì„ ëŒ€ê°œ 반환한다. ë‹¹ì‹ ì€ <literal>Set</literal>ì„ í†µí•´ ì´ë“¤ ì¤‘ë³µë“¤ì„ ê°„ë‹¨í•˜ê²Œ í•„í„°ë§í• 수 있다."
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr "ê²°ê³¼ë“¤ì„ ë°˜ë³µí•˜ê¸°"
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr "종종, ë‹¹ì‹ ì€ <literal>iterate()</literal> 메소드를 사용하여 질ì˜ë¥¼ ì‹¤í–‰í•¨ìœ¼ë¡œì¨ ë” ë‚˜ì€ í¼í¬ë¨¼ìŠ¤ë¥¼ 성취하는 ê²ƒì´ ê°€ëŠ¥í• ìˆ˜ 있다. ì´ê²ƒì€ ì˜¤ì§ ëŒ€ê°œ 질ì˜ì— ì˜í•´ 반환ë˜ëŠ” ì‹¤ì œ 엔티티 ì¸ìŠ¤í„´ìŠ¤ë“¤ì´ ì´ë¯¸ 세션 ë‚´ì— ìžˆê±°ë‚˜ second-level ìºì‹œ ë‚´ì— ìžˆì„ ê²ƒìž„ì„ ë‹¹ì‹ ì´ ì˜ˆìƒí•˜ëŠ” ê²½ìš°ì¼ ê²ƒì´ë‹¤. ë§Œì¼ ê·¸ê²ƒë“¤ì´ ì´ë¯¸ ìºì‹œë˜ì§€ 않았다면, <literal>iterate()</literal>는 <literal>list()</literal> 보다 ë” ëŠë¦´ 것ì´ê³ 간단한 질ì˜ì— 대해 ë§Žì€ ë°ì´í„°ë² ì´ìŠ¤ ì ‘ì†ë“¤ì„, 대개 ì˜¤ì§ ì‹ë³„ìžë“¤ì„ 반환하는 초기 selectì— ëŒ€í•´ <emphasis>1</emphasis>ë²ˆì˜ ì ‘ì†ê³¼ ì‹¤ì œ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 초기화 시키는 추가ì ì¸ selectë“¤ì— ëŒ€í•´ <emphasis>n</emphasis> ë²ˆì˜ ì ‘ì†ì„ 필요로 í• ìˆ˜ 있다."
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr "íŠœí”Œë“¤ì„ ë°˜í™˜í•˜ëŠ” 질ì˜ë“¤"
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr "Hibernate 질ì˜ë“¤ì€ 때때로 ê°ì²´ë“¤ì˜ íŠœí”Œë“¤ì„ ë°˜í™˜í•˜ê³ , ê·¸ ê²½ìš°ì— ê°ê°ì˜ íŠœí”Œì€ ë°°ì—´ë¡œì„œ 반환ëœë‹¤:"
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];
+\n"
+ " Cat mother = (Cat) tuple[1];
+\n"
+ " ....\n"
+ "}]]>"
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr "ìŠ¤ì¹¼ë¼ ê²°ê³¼ë“¤"
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr "질ì˜ë“¤ì€ <literal>select</literal> ì ˆ ë‚´ì— í•˜ë‚˜ì˜ í´ëž˜ìŠ¤ì— 대한 í•˜ë‚˜ì˜ í”„ë¡œí¼í‹°ë¥¼ ì§€ì •í• ìˆ˜ 있다. ê·¸ê²ƒë“¤ì€ ì‹¬ì§€ì–´ SQL 집계 í•¨ìˆ˜ë“¤ì„ í˜¸ì¶œí• ìˆ˜ë„ ìžˆë‹¤. 프로í¼í‹°ë“¤ì´ë‚˜ aggregateë“¤ì€ \"스칼ë¼\" 결과들(ê·¸ë¦¬ê³ ì˜ì† ìƒíƒœì— 있는 ì—”í‹°í‹°ë“¤ì´ ì•„ë‹Œ 것으)ë¡œ 간주ëœë‹¤."
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr "ë°”ì¸ë“œ 프ë¼ë¯¸í„°ë“¤"
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr "<literal>Query</literal> ìƒì˜ ë©”ì†Œë“œë“¤ì€ ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ ë˜ëŠ” JDBC-스타ì¼ì˜ <literal>?</literal> 파ë¼ë¯¸í„°ë“¤ì— ë°”ì¸ë”© ê°’ë“¤ì„ ì œê³µí•œë‹¤. <emphasis>JDBC와는 대조ì 으로, Hibernate ìˆ«ìž íŒŒë¼ë¯¸í„°ë“¤ì€ 0ì—ì„œ 시작ëœë‹¤.</emphasis> ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ì€ ì§ˆì˜ ë¬¸ìžì—´ ì†ì—ì„œ <literal>:name</literal> 형ì‹ì˜ ì‹ë³„ìžë“¤ì´ë‹¤. ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ì˜ 장ì ë“¤ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr "ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ì€ ê·¸ê²ƒë“¤ì´ ì§ˆì˜ ë¬¸ìžì—´ ë‚´ì— ë°œìƒí•˜ëŠ” ìˆœì„œì— ê´€ê³„ì—†ë‹¤"
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr "ê·¸ê²ƒë“¤ì€ ë™ì¼í•œ ì§ˆì˜ ë‚´ì—ì„œ 여러 번 ë°œìƒí• 수 있다"
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr "ê·¸ê²ƒì€ ìžê¸°-설명ì ì´ë‹¤"
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr "<title>쪽매김</title>"
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ê²°ê³¼ ì…‹ì— ê²½ê³„(ë‹¹ì‹ ì´ ê²€ìƒ‰í•˜ê³ ìž ì›í•˜ëŠ” 최대 개수 ê·¸ë¦¬ê³ /ë˜ëŠ” ë‹¹ì‹ ì´ ê²€ìƒ‰í•˜ê³ ìž ì›í•˜ëŠ” 첫 번째 í–‰)ì„ ì§€ì •í• í•„ìš”ê°€ 있다면 ë‹¹ì‹ ì€ <literal>Query</literal> ì¸í„°íŽ˜ì´ìŠ¤ì˜ ë©”ì†Œë“œë“¤ì„ ì‚¬ìš©í•´ì•¼ 한다:"
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr "Hibernate는 ì´ limit 질ì˜ë¥¼ ë‹¹ì‹ ì˜ DBMSì˜ native SQLë¡œ 번ì—하는 ë°©ë²•ì„ ì•Œê³ ìžˆë‹¤."
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr "스í¬ë¡¤ 가능한 iteration"
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr "ë‹¹ì‹ ì˜ JDBC ë“œë¼ì´ë²„ê°€ 스í¬ë¡¤ 가능한 <literal>ResultSet</literal>ë“¤ì„ ì§€ì›í• 경우, <literal>Query</literal> ì¸í„°íŽ˜ì´ìŠ¤ëŠ” <literal>ScrollableResults</literal> ê°ì²´ë¥¼ ì–»ëŠ”ë° ì‚¬ìš©ë 수 ìžˆê³ , ê·¸ê²ƒì€ ì§ˆì˜ ê²°ê³¼ë“¤ì— ëŒ€í•œ ìœ ì—°í•œ 네비게ì´ì…˜ì„ 허용해준다."
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr "ì—´ë ¤ì§„ ë°ì´í„°ë² ì´ìŠ¤ 커넥션(ê³¼ 커서)ê°€ ì´ ê¸°ëŠ¥ì— í•„ìš”í•¨ì„ ë…¸íŠ¸í•˜ê³ , ë§Œì¼ ë‹¹ì‹ ì´ ìª½ë§¤ê¹€ ê¸°ëŠ¥ì„ ìž‘ë™ì‹œí‚¬ 필요가 있다면 <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal>를 사용하ë¼."
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr "ëª…ëª…ëœ ì§ˆì˜ë“¤ì„ 구체화 시키기"
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ 매핑 문서 ì†ì— ëª…ëª…ëœ ì§ˆì˜ë“¤ì„ ì •ì˜í• 수 있다.(ë§Œì¼ ë‹¹ì‹ ì˜ ì§ˆì˜ê°€ 마í¬ì—…으로서 í•´ì„ë 수 있는 문ìžë“¤ì„ í¬í•¨í• ê²½ìš°ì— <literal>CDATA</literal> ì„¹ì…˜ì„ ì‚¬ìš©í•˜ëŠ” ê²ƒì„ ê¸°ì–µí•˜ë¼))"
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr "파ë¼ë¯¸í„° ë°”ì¸ë”©ê³¼ ì‹¤í–‰ì€ í”„ë¡œê·¸ëž¨ ìƒìœ¼ë¡œ 행해진다:"
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr "ì‹¤ì œ 프로그램 코드는 사용ë˜ëŠ” ì§ˆì˜ ì–¸ì–´ì— ë…립ì ì´ê³ , ë‹¹ì‹ ì€ ë˜í•œ 메타ë°ì´í„°ë¡œ native SQL 질ì˜ë“¤ì„ ì •ì˜í• ìˆ˜ë„ ìžˆê±°ë‚˜ ê·¸ê²ƒë“¤ì„ ë§¤í•‘ 파ì¼ë“¤ ì†ì— 기존 질ì˜ë“¤ì„ ìœ„ì¹˜ì§€ì›€ìœ¼ë¡œì¨ ê¸°ì¡´ 질ì˜ë“¤ì„ Hibernateë¡œ ì´ì „시킬 ìˆ˜ë„ ìžˆìŒì„ 노트하ë¼."
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr "ë˜í•œ <literal><hibernate-mapping></literal> 요소 ë‚´ì—ì„œ í•˜ë‚˜ì˜ ì§ˆì˜ ì„ ì–¸ì€ ê·¸ 질ì˜ì— 대한 ì „ì— ìœ ì¼ ì´ë¦„ì„ í•„ìš”ë¡œ í•˜ê³ , ë°˜ë©´ì— <literal><class></literal> 요소 ë‚´ì—ì„œì˜ ì§ˆì˜ ì„ ì–¸ì€ í´ëž˜ìŠ¤ ì´ë¦„으로 수ì§ëœì´ë¦„ì„ ì²¨ê°€í•˜ì—¬ ìžë™ì 으로 ìœ ì¼í•˜ê²Œ 만들어진다. 예를 들어 <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr "ì½œë ‰ì…˜ë“¤ì„ í•„í„°ë§ í•˜ê¸°"
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr "ì½œë ‰ì…˜ <emphasis>í•„í„°</emphasis>는 ì˜ì† ì½œë ‰ì…˜ ë˜ëŠ” ë°°ì—´ì— ì ìš©ë 수 있는 질ì˜ì˜ 특별한 타입ì´ë‹¤. ì§ˆì˜ ë¬¸ìžì—´ì€ í˜„ìž¬ì˜ ì½œë ‰ì…˜ 요소를 ì˜ë¯¸í•˜ëŠ” <literal>this</literal>를 ì°¸ì¡°í• ìˆ˜ 있다."
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr "반환ë˜ëŠ” ì½œë ‰ì…˜ì€ í•˜ë‚˜ì˜ bag으로 간주ë˜ê³ , ê·¸ê²ƒì€ ì£¼ì–´ì§„ ì½œë ‰ì…˜ì— ëŒ€í•œ 사본ì´ë‹¤. ì›ëž˜ì˜ ì½œë ‰ì…˜ì€ ë³€ê²½ë˜ì§€ 않는다 (ì´ê²ƒì€ ì´ë¦„ \"filter\"ì˜ ì˜ë¯¸ì™€ëŠ” ì •ë°˜ëŒ€ì´ì§€ë§Œ, 예ìƒë˜ëŠ” 행위와 ì¼ì¹˜ëœë‹¤)."
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr "í•„í„°ë“¤ì€ <literal>from</literal> ì ˆì„ í•„ìš”ë¡œ 하지 ì•ŠìŒì„ 관찰하ë¼(í•„ìš”í• ê²½ìš°ì— í•„í„°ë“¤ì´ í•œ ê°œì˜ from ì ˆì„ ê°€ì§ˆ 수 있ì„지ë¼ë„). í•„í„°ë“¤ì€ ì½œë ‰ì…˜ 요소들 ìžì²´ë“¤ì„ 반환하는 것으로 í•œì •ë˜ì§€ 않는다."
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr "심지어 í•˜ë‚˜ì˜ ê³µë°±ì˜ í•„í„° 질ì˜ë„ 예를 들어 거대한 ì½œë ‰ì…˜ ë‚´ì— ìžˆëŠ” ìš”ì†Œë“¤ì˜ ë¶€ë¶„ì§‘í•©ë“¤ì„ ë¡œë“œì‹œí‚¤ëŠ”ë° ìœ ìš©í•˜ë‹¤:"
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr "Criteria 질ì˜ë“¤"
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr "HQLì€ ê·¹ížˆ ê°•ë ¥í•˜ì§€ë§Œ 몇몇 개발ìžë“¤ì€ ì§ˆì˜ ë¬¸ìžì—´ë“¤ì„ 빌드하기 보다, ê°ì²´ 지향 API를 사용하여 ë™ì 으로 질ì˜ë“¤ì„ 빌드시키는 ê²ƒì„ ì„ í˜¸í•œë‹¤. Hibernate는 ì´ë“¤ ê²½ìš°ë“¤ì„ ìœ„í•œ ì§ê´€ì ì¸ <literal>Criteria</literal> query API를 ì œê³µí•œë‹¤:"
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr "<literal>Criteria</literal>와 ì—°ê´€ëœ <literal>Example</literal> API 는 <xref linkend=\"querycriteria\"/>ì—ì„œ ìƒì„¸í•˜ê²Œ ë…¼ì˜ëœë‹¤."
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr "native SQLì—ì„œ 질ì˜ë“¤"
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr "ë‹¹ì‹ ì€ <literal>createSQLQuery()</literal>를 사용하여 SQL ì†ì— í•˜ë‚˜ì˜ ì§ˆì˜ë¥¼ í‘œí˜„í• ìˆ˜ ìžˆê³ , Hibernateë¡œ 하여금 ê²°ê³¼ 셋들로부터 ê°ì²´ë“¤ë¡œì˜ ë§¤í•‘ì„ ì²˜ë¦¬í•˜ë„ë¡ í• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì€ ì•„ë¬´ë•Œë‚˜ <literal>session.connection()</literal>ì„ í˜¸ì¶œí• ìˆ˜ ìžˆê³ ì§ì ‘ JDBC <literal>Connection</literal>ì„ ì‚¬ìš©í• ìˆ˜ 있ìŒì„ 노트하ë¼. ë§Œì¼ ë‹¹ì‹ ì´ Hibernate API를 ì‚¬ìš©í•˜ê³ ìž ì„ íƒí•œ ê²½ìš°ì— , ë‹¹ì‹ ì€ SQL aliasë“¤ì„ ì¤‘ê´„í˜¸ë“¤ ì†ì— í¬í•¨ì‹œì¼œì•¼ 한다:"
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list();]]>"
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr ""
+ "<![CDATA[List cats = session.createSQLQuery(
+\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +
+\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +
+\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")
+\n"
+ " .addEntity(\"cat\", Cat.class)
+\n"
+ ".list()]]>"
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr "SQL 질ì˜ë“¤ì€ Hibernate 질ì˜ë“¤ì²˜ëŸ¼ ëª…ëª…ëœ íŒŒë¼ë¯¸í„°ë“¤ê³¼ 위치 파ë¼ë¯¸í„°ë“¤ì„ í¬í•¨í• ìˆ˜ë„ ìžˆë‹¤. SQL 질ì˜ë“¤ì— 대한 추가 ì •ë³´ëŠ” <xref linkend=\"querysql\"/>ì—ì„œ ì°¾ì„ ìˆ˜ 있다."
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr "ì˜ì† ê°ì²´ë“¤ì„ 변경하기"
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr "<emphasis>트랜ìžì…˜ ìƒì˜ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤</emphasis> (예를들면. <literal>Session</literal>ì— ì˜í•´ 로드ë˜ê³ , ì €ìž¥ë˜ê³ , ìƒì„±ë˜ê±°ë‚˜ 질ì˜ëœ ê°ì²´ë“¤)ì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— ì˜í•´ 처리ë 수 ìžˆê³ ì˜ì† ìƒíƒœì— 대한 ìž„ì˜ì˜ ë³€ê²½ë“¤ì€ <literal>Session</literal>ì´ <emphasis>flushë </emphasis> ë•Œ ì˜ì†í™” ë 것ì´ë‹¤(ì´ ìž¥ì˜ ë’· 부분ì—ì„œ ë…¼ì˜ë¨). ë‹¹ì‹ ì˜ ë³€ê²½ë“¤ì„ ì˜ì†í™” 시키기 위해 (다른 ìš©ë„를 가진 <literal>update()</literal>와 ê°™ì€) 특별한 메소드를 í˜¸ì¶œí• í•„ìš”ê°€ 없다. ë”°ë¼ì„œ ê°ì²´ì˜ ìƒíƒœë¥¼ ì—…ë°ì´íŠ¸ 시키는 가장 간단한 ë°©ë²•ì€ <literal>Session</literal>ì´ ì—´ë ¤ 있는 ë™ì•ˆ, ê·¸ê²ƒì„ <literal>load()</literal>ì‹œí‚¤ê³ ë‚˜ì„œ, ê·¸ê²ƒì„ ì§ì ‘ 처리하는 것ì´ë‹¤:"
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr "때때로 ì´ í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ì€ ë¶ˆì¶©ë¶„í•˜ë‹¤. 왜ëƒí•˜ë©´ ê·¸ê²ƒì€ ë™ì¼í•œ 세션 ë‚´ì—ì„œ (ê°ì²´ë¥¼ 로드시키는) SQL <literal>SELECT</literal>와 (ê·¸ê²ƒì˜ ì—…ë°ì´íŠ¸ëœ ìƒíƒœë¥¼ ì˜ì†í™” 시키는) SQL <literal>UPDATE</literal> ì–‘ìžë¥¼ 필요로 í• ê²ƒì´ê¸° 때문ì´ë‹¤. 그러므로 Hibernate는 detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 사용하는 대안ì ì¸ ì ‘ê·¼ë²•ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr "Hibernate는 <literal>UPDATE</literal> 문장 ë˜ëŠ” <literal>DELETE</literal> ë¬¸ìž¥ì˜ ì§ì ‘ì ì¸ ì‹¤í–‰ì„ ìœ„í•œ 그것 ìžì‹ ì˜ API를 ì œê³µí•˜ì§€ ì•ŠìŒì„ 노트하ë¼. Hibernate는 í•˜ë‚˜ì˜ <emphasis>ìƒíƒœ 관리</emphasis> 서비스ì´ê³ , ë‹¹ì‹ ì€ ê·¸ê²ƒì„ ì‚¬ìš©í• <emphasis>문장들</emphasis>ì„ ìƒê°í•˜ì§€ ë§ì•„야 한다. JDBC는 SQL ë¬¸ìž¥ë“¤ì„ ì‹¤í–‰ì‹œí‚¤ëŠ” ì™„ì „í•œ APIì´ê³ , ë‹¹ì‹ ì€ <literal>session.connection()</literal>ì„ í˜¸ì¶œí•˜ì—¬ 아무때나 í•œ ê°œì˜ JDBC <literal>Connection</literal>ì„ ì–»ì„ ìˆ˜ 있다. 게다가 대량 오í¼ë ˆì´ì…˜ì˜ ê°œë…ì€ ì˜¨ë¼ì¸ 트랜ìžì…˜ 처리-지향ì ì¸ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì„ 위한 ê°ì²´/관계형 매핑과 충ëŒí•œë‹¤. 하지만 Hibernateì˜ ìž¥ëž˜ ë²„ì „ë“¤ì€ íŠ¹ë³„í•œ ëŒ€ìš©ëŸ‰ì˜ ì˜¤í¼ë ˆì´ì…˜ ê¸°ëŠ¥ë“¤ì„ ì œê³µí• ìˆ˜ë„ ìžˆë‹¤. 몇몇 가능한 배치 오í¼ë ˆì´ì…˜ 트ë¦ë“¤ì— 대해서는 <xref linkend=\"batch\"/>ì„ ë³´ë¼."
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr "detached ê°ì²´ë“¤ì„ 변경시키기"
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr "ë§Žì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì€ í•˜ë‚˜ì˜ íŠ¸ëžœìžì…˜ ë‚´ì—ì„œ í•˜ë‚˜ì˜ ê°ì²´ë¥¼ ê²€ìƒ‰í•˜ê³ , 처리를 위한 UI 계층으로 ê·¸ê²ƒì„ ì „ì†¡í•˜ê³ , 그런 ë‹¤ìŒ ìƒˆë¡œìš´ 트랜ìžì…˜ ë‚´ì—ì„œ ë³€ê²½ë“¤ì„ ì €ìž¥í• í•„ìš”ê°€ 있다. ê³ ë„ì˜-ë™ì‹œì„± 환경ì—ì„œ ì´ëŸ° ì¢…ë¥˜ì˜ ì ‘ê·¼ë²•ì„ ì‚¬ìš©í•˜ëŠ” 어플리케ì´ì…˜ë“¤ì€ 대개 ìž‘ì—…ì˜ \"긴\" 단위를 확실히 격리시키기 위해 ë²„ì „í™” ëœ ë°ì´í„°ë¥¼ 사용한다."
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr "Hibernate는 <literal>Session.update()</literal> 메소드 ë˜ëŠ” <literal>Session.merge()</literal> 메소드를 사용하여 detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ 재첨부를 ì œê³µí•¨ìœ¼ë¡œì¨ ì´ ëª¨í˜•ì„ ì§€ì›í•œë‹¤:"
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr "ë§Œì¼ <literal>catId</literal> ì‹ë³„ìžë¥¼ 가진 <literal>Cat</literal>ì´ <literal>secondSession</literal>ì— ì˜í•´ ì´ë¯¸ 로드ë˜ì—ˆì„ ê²½ìš°ì— ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ê·¸ê²ƒì„ ë‹¤ì‹œ ìž¬ì²¨ë¶€í•˜ë ¤ê³ ì‹œë„í• ë•Œ, 예외ìƒí™©ì´ ë˜ì ¸ì¡Œì„ 것ì´ë‹¤."
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr "ë§Œì¼ ê·¸ ì„¸ì…˜ì´ ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가진 ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì´ë¯¸ í¬í•¨í•˜ì§€ ì•ŠìŒì„ ë‹¹ì‹ ì´ í™•ì‹ í•˜ëŠ” 경우ì—는 <literal>update()</literal>를 ì‚¬ìš©í•˜ê³ , ë§Œì¼ ë‹¹ì‹ ì´ ì„¸ì…˜ì˜ ìƒíƒœë¥¼ ê³ ë ¤í•˜ì§€ ì•Šì€ì±„ë¡œ 아무때나 ë‹¹ì‹ ì˜ ë³€ê²½ì„ ë³‘í•©ì‹œí‚¤ê³ ìž ì›í• 경우ì—는 <literal>merge()</literal>를 사용하ë¼. 달리 ë§í•´, ë‹¹ì‹ ì˜ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대한 재첨부가 실행ë˜ëŠ” 첫 번째 오í¼ë ˆì´ì…˜ìž„ì„ í™•ì‹¤ížˆ 함으로ì¨, <literal>update()</literal>는 대개 ê°“ 만들어진 세션ì—ì„œ ë‹¹ì‹ ì´ í˜¸ì¶œí•˜ê²Œ ë 첫 번째 메소드ì´ë‹¤."
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr "어플리케ì´ì…˜ì€ ë§Œì¼ ê·¸ê²ƒì´ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ ìƒíƒœê°€ ë˜í•œ ì—…ë°ì´íŠ¸ ë˜ëŠ” ê²ƒì„ ì›í• 경우ì—<emphasis>만</emphasis> 주어진 detached ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° ë„달 가능한 detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 개별ì 으로<literal>update()</literal> 시킬 것ì´ë‹¤. ì´ê²ƒì€ ë¬¼ë¡ <emphasis>transitive persistence(ì „ì´ ì˜ì†)</emphasis>ì„ ì‚¬ìš©í•˜ì—¬ ìžë™í™” ë 수 ìžˆê³ , <xref linkend=\"objectstate-transitive\"/>를 ë³´ë¼."
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr "<literal>lock()</literal> 메소드는 ë˜í•œ í•˜ë‚˜ì˜ ê°ì²´ë¥¼ 새로운 ì„¸ì…˜ì— ëŒ€í•´ 다시 ì—°ê´€ì‹œí‚¤ëŠ”ê²ƒì„ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—게 허용해준다. 하지만 detached ì¸ìŠ¤í„´ìŠ¤ëŠ” 변경ë˜ì§€ 않아야 한다!"
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr "<literal>lock()</literal>ì´ ì—¬ëŸ¬ê°€ì§€ <literal>LockMode</literal>ë“¤ì— ì‚¬ìš©ë 수 있ìŒì„ ë…¸íŠ¸í•˜ê³ , ìƒì„¸í•œ ê²ƒì€ API 문서와 트랜ìžì…˜ ì²˜ë¦¬ì— ê´€í•œ ìž¥ì„ ë³´ë¼. 재첨부는 <literal>lock()</literal>ì— ëŒ€í•œ ìœ ì¼í•œ 쓰임새는 아니다."
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr "긴 ìž‘ì—… ë‹¨ìœ„ì— ëŒ€í•œ 다른 ëª¨í˜•ë“¤ì€ <xref linkend=\"transactions-optimistic\"/>ì—ì„œ ë…¼ì˜ëœë‹¤."
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr "ìžë™ì ì¸ ìƒíƒœ 검출"
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr "Hibernate 사용ìžë“¤ì€ 새로운 ì‹ë³„ìžë¥¼ ìƒì„±ì‹œì¼œì„œ transient ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì €ìž¥í•˜ê±°ë‚˜ ê·¸ê²ƒì˜ í˜„ìž¬ ì‹ë³„ìžì™€ ì—°ê´€ëœ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ì—…ë°ì´íŠ¸/재첨부 시키는 ì¼ë°˜ì ì¸ ìš©ë„ì˜ ë©”ì†Œë“œë¥¼ ìš”ì²í–ˆë‹¤. <literal>saveOrUpdate()</literal> 메소드는 ì´ ê¸°ëŠ¥ì„ êµ¬í˜„í•œë‹¤."
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr "<literal>saveOrUpdate()</literal>ì˜ ì‚¬ìš© ì˜ˆì œì™€ ì˜ë¯¸ëŠ” 초심ìžë“¤ì—게는 혼ë™ìŠ¤ëŸ¬ì›Œ ë³´ì¸ë‹¤. ë¨¼ì €, í•˜ë‚˜ì˜ ì„¸ì…˜ì—ì„œ 온 ì¸ìŠ¤í„´ìŠ¤ë¥¼ ë˜ ë‹¤ë¥¸ 새로운 세션 ë‚´ì—ì„œ ì‚¬ìš©í•˜ë ¤ê³ ì‹œë„하지 않는 í•œ, ë‹¹ì‹ ì€ <literal>update()</literal>, <literal>saveOrUpdate()</literal>, ë˜ëŠ” <literal>merge()</literal>를 ì‚¬ìš©í• í•„ìš”ëŠ” ì—†ì„ ê²ƒì´ë‹¤. 몇몇 ì „ì²´ 어플리케ì´ì…˜ë“¤ì€ ì´ë“¤ 메소드들 중 ì–´ëŠ ê²ƒë„ ê²°ì½” 사용하지 ì•Šì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr "대개 <literal>update()</literal> ë˜ëŠ” <literal>saveOrUpdate()</literal>는 ë‹¤ìŒ ì‹œë‚˜ë¦¬ì˜¤ì—ì„œ 사용ëœë‹¤:"
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr "어플리케ì´ì…˜ì´ 첫 번째 세션 ë‚´ì— ê°ì²´ë¥¼ 로드시킨다"
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr "ê°ì²´ê°€ UI í‹°ì–´ë¡œ ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr "몇몇 ë³€ê²½ë“¤ì´ ê·¸ ê°ì²´ì— 행해진다"
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr "ê°ì²´ê°€ 비지니스 ë¡œì§ í‹°ì–´ë¡œ ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr "어플리케ì´ì…˜ì€ ë‘ ë²ˆì§¸ 세션ì—ì„œ <literal>update()</literal>를 í˜¸ì¶œí•¨ìœ¼ë¡œì¨ ì´ë“¤ ë³€ê²½ë“¤ì„ ì˜ì†í™” 시킨다"
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr "<literal>saveOrUpdate()</literal>는 다ìŒì„ 행한다:"
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr "ë§Œì¼ ê°ì²´ê°€ ì´ ì„¸ì…˜ ë‚´ì—ì„œ ì´ë¯¸ ì˜ì†í™” ë˜ì–´ ìžˆì„ ê²½ìš°, ì•„ë¬´ê²ƒë„ í–‰í•˜ì§€ 않는다"
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr "ë§Œì¼ ê·¸ 세션과 ì—°ê´€ëœ ë˜ ë‹¤ë¥¸ ê°ì²´ê°€ ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가질 경우, 예외ìƒí™©ì„ ë˜ì§„다"
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr "ë§Œì¼ ê·¸ ê°ì²´ê°€ ì‹ë³„ìž í”„ë¡œí¼í‹°ë¥¼ 갖지 ì•Šì„ ê²½ìš°, ê·¸ê²ƒì„ <literal>save()</literal> 시킨다"
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr "ë§Œì¼ ê°ì²´ì˜ ì‹ë³„ìžê°€ ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ ê°ì²´ì— í• ë‹¹ëœ ê°’ì„ ê°€ì§ˆ 경우, ê·¸ê²ƒì„ <literal>save()</literal> 시킨다"
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr "ë§Œì¼ ê°ì²´ê°€ (<literal><version></literal> ë˜ëŠ” <literal><timestamp></literal>ì— ì˜í•´) ë²„ì „í™” ë˜ê³ , version 프로í¼í‹° ê°’ì´ ìƒˆë¡œì´ ì´ˆê¸°í™” ëœ ê°ì²´ì— í• ë‹¹ëœ ê²ƒê³¼ ë™ì¼í•œ ê°’ì¼ ê²½ìš°, ê·¸ê²ƒì„ <literal>save()</literal> 시킨다"
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "ê·¸ ë°–ì˜ ê²½ìš° ê·¸ ê°ì²´ë¥¼ <literal>update()</literal> 시킨다"
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "ê·¸ë¦¬ê³ <literal>merge()</literal>는 매우 다르다:"
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr "ë§Œì¼ ì„¸ì…˜ê³¼ 현재 ì—°ê´€ëœ ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가진 ì˜ì† ì¸ìŠ¤í„´ìŠ¤ê°€ ì¡´ìž¬í• ê²½ìš°, 주어진 ê°ì²´ì˜ ìƒíƒœë¥¼ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ ìƒìœ¼ë¡œ 복사한다"
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr "ë§Œì¼ ì„¸ì…˜ê³¼ 현재 ì—°ê´€ëœ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ê°€ 존재하지 ì•Šì„ ê²½ìš°, ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ê·¸ê²ƒì„ ë¡œë“œì‹œí‚¤ë ¤ê³ ì‹œë„하거나 새로운 ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë¥¼ ìƒì„±ì‹œí‚¤ë ¤ê³ ì‹œë„한다"
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr "ì˜ì† ì¸ìŠ¤í„´ìŠ¤ê°€ 반환ëœë‹¤"
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr "주어진 ì¸ìŠ¤í„´ìŠ¤ëŠ” 세션과 ì—°ê´€ë˜ì§€ ì•Šê³ , ê·¸ê²ƒì€ detached ìƒíƒœì— 머무른다"
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr "ì˜ì† ê°ì²´ë“¤ì„ ì‚ì œí•˜ê¸°"
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr "<literal>Session.delete()</literal>는 ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ê°ì²´ì˜ ìƒíƒœë¥¼ ì œê±°í• ê²ƒì´ë‹¤. ë¬¼ë¡ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì€ ì—¬ì „ížˆ detached ê°ì²´ì— 대한 참조를 ì†Œìœ í• ê²ƒì´ë‹¤. ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë¥¼ transientë¡œ 만들 ë•Œ <literal>delete()</literal>를 ìƒê°í•˜ëŠ” ê²ƒì´ ìµœìƒì´ë‹¤."
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr "<![CDATA[sess.delete(cat);]]>"
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr "ë‹¹ì‹ ì€ foreign 키 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ ìœ„ë°°ë“¤ì— ëŒ€í•œ 위험성 ì—†ì´ ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ì–´ë–¤ 순서로 ê°ì²´ë“¤ì„ ì‚ì œí• ìˆ˜ë„ ìžˆë‹¤. ìž˜ëª»ëœ ìˆœì„œë¡œ ê°ì²´ë“¤ì„ ì‚ì œí•¨ìœ¼ë¡œì¨ foreign 키 ì»¬ëŸ¼ì— ëŒ€í•œ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìœ„ë°°í• ê°€ëŠ¥ì„±ì´ ì—¬ì „ížˆ 존재한다. 예를 들어, ë‹¹ì‹ ì´ ë¶€ëª¨ë¥¼ ì‚ì œí•˜ì§€ë§Œ, ê·¸ ìžì‹ë“¤ì„ ì‚ì œí•˜ëŠ” ê²ƒì„ ìžŠì€ ê²½ìš°."
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr "ë‘ ê°œì˜ ë‹¤ë¥¸ ë°ì´í„°ì €ìž¥ì†Œë“¤ 사ì´ì— ê°ì²´ë“¤ì„ ë³µì œí•˜ê¸°"
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr "ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ 그래프를 ì·¨í•˜ê³ ì‹ë³„ìž ê°’ë“¤ì„ ë‹¤ì‹œ ìƒì„±ì‹œí‚¤ì§€ ì•Šê³ ì„œ ê·¸ê²ƒë“¤ì„ ë‹¤ë¥¸ ì €ìž¥ì†Œ ì†ì— ì˜ì†í™” 시키는 ê²ƒì„ ê°€ëŠ¥í•˜ë„ë¡ ë§Œë“œëŠ” ê²ƒì´ ì¢…ì¢… ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr "<literal>ReplicationMode</literal>는 <literal>replicate()</literal>ê°€ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ìžˆëŠ” ê¸°ì¡´ì˜ í–‰ë“¤ê³¼ì˜ ì¶©ëŒì„ 처리하게ë ë°©ë²•ì„ ê²°ì •í•œë‹¤."
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr "<literal>ReplicationMode.IGNORE</literal> - ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가진 기존 ë°ì´í„°ë² ì´ìŠ¤ í–‰ì´ ì¡´ìž¬í• ê²½ìš°ì— ê·¸ ê°ì²´ë¥¼ 무시한다"
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr "<literal>ReplicationMode.OVERWRITE</literal> - ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가진 ì–´ë–¤ ê¸°ì¡´ì˜ ë°ì´í„°ë² ì´ìŠ¤ í–‰ì„ ë®ì–´ 쓴다"
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.EXCEPTION</literal> - ë§Œì¼ ë™ì¼í•œ ì‹ë³„ìžë¥¼ 가진 기존 ë°ì´í„°ë² ì´ìŠ¤ í–‰ì´ ì¡´ìž¬í• ê²½ìš°ì— ì˜ˆì™¸ìƒí™©ì„ ë˜ì§„다"
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.LATEST_VERSION</literal> - í–‰ì˜ ë²„ì „ 번호가 ê°ì²´ì˜ ë²„ì „ 번호 보다 ì´ì „ì˜ ê²ƒì´ë©´ ë®ì–´ì“°ê³ , ê·¸ ë°–ì˜ ê²½ìš°ì— ê·¸ ê°ì²´ë¥¼ 무시한다"
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr "ì´ íŠ¹ì§•ì˜ ì“°ìž„ìƒˆë“¤ì€ ë‹¤ë¥¸ ë°ì´í„°ë² ì´ìŠ¤ ì¸ìŠ¤í„´ìŠ¤ë“¤ ì†ìœ¼ë¡œ ìž…ë ¥ëœ ë°ì´í„° ì¼ì¹˜ì‹œí‚¤ê¸°, ì œí’ˆ ì—…ê·¸ë ˆì´ë“œ ë™ì•ˆì— 시스템 구성 ì •ë³´ ì—…ë°ì´íŠ¸ 하기, non-ACID 트랜ìžì…˜ë“¤ ë™ì•ˆì— 행해진 ë³€ê²½ë“¤ì„ ë¡¤ë°±ì‹œí‚¤ê¸° ë“±ì„ í¬í•¨í•œë‹¤."
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr "Sessionì„ flush 시키기"
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr "ì‹œê°„ì´ ì§€ë‚¨ì— ë”°ë¼ <literal>Session</literal>ì€ JDBC ì»¤ë„¥ì…˜ì˜ ìƒíƒœì™€ 메모리 ë‚´ì— ë³´ê´€ëœ ê°ì²´ë“¤ì˜ ìƒíƒœë¥¼ ë™ê¸°í™” ì‹œí‚¤ëŠ”ë° í•„ìš”í•œ SQL ë¬¸ìž¥ë“¤ì„ ì‹¤í–‰ì‹œí‚¬ 것ì´ë‹¤. ì´ í”„ë¡œì„¸ìŠ¤ <emphasis>flush</emphasis>는 ë‹¤ìŒ ì‹œì 들ì—ì„œ ë””í´íŠ¸ë¡œ ë°œìƒí•œë‹¤"
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr "몇몇 질ì˜ë“¤ì´ 실행ë˜ê¸° ì „ì—"
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr "<literal>org.hibernate.Transaction.commit()</literal> ì‹œì ì—ì„œ"
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr "<literal>Session.flush()</literal> ì‹œì ì—ì„œ"
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr "SQL ë¬¸ìž¥ë“¤ì´ ë‹¤ìŒ ìˆœì„œë¡œ 실행 ëª…ë ¹ì´ ë‚´ë ¤ì§„ë‹¤"
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr "대ì‘하는 ê°ì²´ë“¤ì´ <literal>Session.save()</literal>를 사용하여 ì €ìž¥ë˜ì—ˆë˜ 것과 ê°™ì€ ìˆœì„œë¡œ, ëª¨ë“ ì—”í‹°í‹° 삽입들"
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr "ëª¨ë“ ì—”í‹°í‹° ì—…ë°ì´íŠ¸ë“¤"
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr "ëª¨ë“ ì½œë ‰ì…˜ ì‚ì œë“¤"
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr "ëª¨ë“ ì½œë ‰ì…˜ 요소 ì‚ì œë“¤, ì—…ë°ì´íŠ¸ë“¤ ê·¸ë¦¬ê³ ì‚½ìž…ë“¤"
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr "ëª¨ë“ ì½œë ‰ì…˜ 삽입들"
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr "대ì‘하는 ê°ì²´ë“¤ì´ <literal>Session.delete()</literal>를 사용하여 ì‚ì œë˜ì—ˆë˜ 것과 ê°™ì€ ìˆœì„œë¡œ ëª¨ë“ ì—”í‹°í‹° ì‚ì œë“¤."
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr "(한가지 예외는 ê°ì²´ë“¤ì´ ì €ìž¥ë ë•Œ <literal>native</literal> ID ìƒì„±ì„ 사용하는 ê°ì²´ë“¤ì´ insert ë˜ëŠ” ì ì´ë‹¤.)"
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr "ë‹¹ì‹ ì´ ëª…ì‹œì 으로 <literal>flush()</literal> 시킬 때를 ì œì™¸í•˜ë©´, <literal>Session</literal>ì´ JDBC í˜¸ì¶œë“¤ì„ ì‹¤í–‰ì‹œí‚¤ëŠ” <emphasis>ì‹œì </emphasis>, ê·¸ê²ƒë“¤ì´ ì‹¤í–‰ë˜ëŠ” <emphasis>순서</emphasis>ë§Œì„ ì ˆëŒ€ì 으로 보장하지는 않는다. 하지만 Hibernate는 <literal>Query.list(..)</literal>ê°€ ì‹¤íš¨ì„±ì´ ì—†ëŠ” ë°ì´í„°ë¥¼ ê²°ì½” 반환하지 ì•Šì„ ê²ƒìž„ì„ ë³´ìž¥í•˜ê±°ë‚˜; ê·¸ê²ƒë“¤ì´ ìž˜ëª»ëœ ë°ì´í„°ë„ 반환하지 ì•Šì„ ê²ƒìž„ì„ ë³´ìž¥í•œë‹¤."
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr "flushê°€ 너무 ìžì£¼ ë°œìƒí•˜ì§€ ì•Šë„ë¡ ë””í´íŠ¸ 행위를 변경하는 ê²ƒì´ ê°€ëŠ¥í•˜ë‹¤. <literal>FlushMode</literal> í´ëž˜ìŠ¤ëŠ” 세 ê°œì˜ ë‹¤ë¥¸ ëª¨ë“œë“¤ì„ ì •ì˜í•œë‹¤: ì˜¤ì§ ì»¤ë°‹ ì‹œ(ê·¸ë¦¬ê³ Hibernate <literal>Transaction</literal> APIê°€ 사용ë ë•Œì—만) flush 모드, ì„¤ëª…ëœ ë£¨í‹´ì„ ì‚¬ìš©í•˜ëŠ” ìžë™ì ì¸ flush 모드, ë˜ëŠ” <literal>flush()</literal>ê°€ 명시ì 으로 호출ë˜ì§€ 않는 í•œ flush 시키지 않는 모드. 마지막 모드는 오래 ë™ì•ˆ 실행ë˜ëŠ” ìž‘ì—… ë‹¨ìœ„ì— ëŒ€í•´ ìœ ìš©í•˜ê³ , 여기서 <literal>Session</literal>ì€ ì—´ë ¤ì§„ì±„ë¡œ ìœ ì§€ë˜ê³ 오랜 시간 ë™ì•ˆ ì—°ê²°ì´ í•´ì œëœ ì±„ë¡œ ìœ ì§€ëœë‹¤. (<xref linkend=\"transactions-optimistic-longsession\"/>를 ë³´ë¼)."
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr "flush ë™ì•ˆì—, í•˜ë‚˜ì˜ ì˜ˆì™¸ìƒí™©ì´ ë°œìƒí• ìˆ˜ë„ ìžˆë‹¤(예를 들면. ë§Œì¼ DML 오í¼ë ˆì´ì…˜ì´ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìœ„ë°˜í• ê²½ìš°). 예외ìƒí™©ë“¤ì„ 처리하는 ê²ƒì€ Hibernatemì˜ íŠ¸ëžœìžì…˜ íŠ¹ì§•ì— ê´€í•œ ì–´ë–¤ ì´í•´ë¥¼ 수반하며, 우리는 <xref linkend=\"transactions\"/>ì—ì„œ ê·¸ê²ƒì„ ë…¼ì˜í•œë‹¤."
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr "Transitive persistence(ì „ì´ ì˜ì†)"
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr "특히 ë‹¹ì‹ ì´ ì—°ê´€ëœ ê°ì²´ë“¤ì˜ 그래프를 다룰 경우ì—, 특히 개별 ê°ì²´ë“¤ì„ ì €ìž¥í•˜ê³ , ì‚ì œí•˜ê±°ë‚˜, 재첨부시키는 ê²ƒì´ ê½¤ 번거ë¡ë‹¤. ê³µí†µëœ ê²½ìš°ëŠ” í•˜ë‚˜ì˜ ë¶€ëª¨/ìžì‹ 관계ì´ë‹¤. ë‹¤ìŒ ì˜ˆì œë¥¼ ê²€í† í•˜ìž:"
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr "ë§Œì¼ ë¶€ëª¨/ìžì‹ 관계ì—ì„œ ìžì‹ë“¤ì´ ê°’(value) 타입(예를 들면. 주소들 ë˜ëŠ” 문ìžì—´ë“¤ì„ 가진 í•˜ë‚˜ì˜ ì½œë ‰ì…˜)ì¼ ê²½ìš°, ê·¸ê²ƒë“¤ì˜ ìƒëª…주기는 ë¶€ëª¨ì— ì˜ì¡´í• 것ì´ê³ ìƒíƒœ ë³€ê²½ë“¤ì— ëŒ€í•´ 편리한 \"케스케ì´ë”©\"ì— ë” ì´ìƒì˜ ì•¡ì…˜ì´ í•„ìš”í•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. ë§Œì¼ ë¶€ëª¨ê°€ ì €ìž¥ë ë•Œ, ê°’(value)-íƒ€ìž…ì˜ ìžì‹ ê°ì²´ë“¤ë„ 마찬가지로 ì €ìž¥ë˜ê³ , 부모가 ì‚ì œë ë•Œ, ìžì‹ë“¤ì´ ì‚ì œë 것ì´ë‹¤. ì´ê²ƒì€ 심지어 ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° í•˜ë‚˜ì˜ ìžì‹ì„ ì œê±°í•˜ëŠ” 그런 오í¼ë ˆì´ì…˜ë“¤ì— ëŒ€í•´ì„œë„ ë™ìž‘한다; Hibernate는 ì´ê²ƒì„ ê²€ì¶œí•˜ê³ , ê°’(value)-íƒ€ìž…ì˜ ê°ì²´ë“¤ì€ 참조를 ê³µìœ í• ìˆ˜ 없으므로, ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ê·¸ ìžì‹ì„ ì‚ì œì‹œí‚¨ë‹¤."
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr "ì´ì œ ê°’(value) íƒ€ìž…ì´ ì•„ë‹Œ, ì—”í‹°í‹°ë“¤ì¸ ë¶€ëª¨ì™€ ìžì‹ ê°ì²´ë“¤ì„ 가진 ë™ì¼í•œ 시나리오를 ê²€í† í•˜ìž(예를 들면. ì¹´í…Œê³ ë¦¬ë“¤ê³¼ ì•„ì´í…œë“¤, ë˜ëŠ” 부모 ê³ ì–‘ì´ë‚˜ ìžì‹ ê³ ì–‘ì´). ì—”í‹°í‹°ë“¤ì€ ê·¸ê²ƒë“¤ ìžì‹ ì˜ ìƒëª…주기를 ê°–ê³ , ê³µìœ ëœ ì°¸ì¡°ë“¤ì„ ì§€ì›í•˜ê³ (ë”°ë¼ì„œ ì½œë ‰ì…˜ìœ¼ë¡œë¶€í„° í•˜ë‚˜ì˜ ì—”í‹°í‹°ë¥¼ ì œê±°í•˜ëŠ” ê²ƒì€ ê·¸ê²ƒì´ ì‚ì œë 수 있ìŒì„ ì˜ë¯¸í•˜ì§€ 않는다), ê·¸ë¦¬ê³ ë””í´íŠ¸ë¡œ í•˜ë‚˜ì˜ ì—”í‹°í‹°ë¡œë¶€í„° ì–´ë–¤ 다른 ì—°ê´€ëœ ì—”í‹°í‹°ë“¤ë¡œì˜ ìƒíƒœì˜ 케스케ì´ë”©ì€ 존재하지 않는다. Hibernate는 ë””í´íŠ¸ë¡œ <emphasis>ë„ë‹¬ê°€ëŠ¥ì„±ì— ì˜í•œ ì˜ì†ì„±(persistence by reachability)</emphasis>ì„ êµ¬í˜„í•˜ì§€ 않는다."
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr "- <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal>를 í¬í•¨í•˜ëŠ”- Hibernate ì„¸ì…˜ì— ëŒ€í•œ ê°ê°ì˜ 기본 오í¼ë ˆì´ì…˜ì— 대해서 í•˜ë‚˜ì˜ ëŒ€ì‘하는 케스케ì´ë”© 스타ì¼ì´ 존재한다. 케스케ì´ë“œ 스타ì¼ë“¤ ê°ê°ì€ <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>ë¡œ 명명ëœë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ ì˜¤í¼ë ˆì´ì…˜ì´ í•˜ë‚˜ì˜ ì—°ê´€ì— ë”°ë¼ ì¼€ìŠ¤ì¼€ì´ë”©ë˜ëŠ” ê²ƒì„ ì›í• 경우, ë‹¹ì‹ ì€ ë§¤í•‘ 문서 ë‚´ì— ê·¸ê²ƒì„ ì§€ì‹œí•´ì•¼ 한다. 예를 들면:"
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr "케스케ì´ë”© 스타ì¼ë“¤ì´ ê²°í•©ë ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr "ë‹¹ì‹ ì€ <emphasis>ëª¨ë“ </emphasis> 오í¼ë ˆì´ì…˜ë“¤ì´ ê·¸ ì—°ê´€ì— ë”°ë¼ ì¼€ìŠ¤ì¼€ì´ë“œ ë˜ì–´ì•¼ í•¨ì„ ì§€ì •í•˜ëŠ”ë° <literal>cascade=\"all\"</literal>ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤. ë””í´íŠ¸<literal>cascade=\"none\"</literal>ì€ ì˜¤í¼ë ˆì´ì…˜ë“¤ì´ 케스케ì´ë“œ ë˜ì§€ ì•Šì„ ê²ƒìž„ì„ ì§€ì •í•œë‹¤."
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr "íŠ¹ì •í•œ 케스케ì´ë“œ 스타ì¼ì¸, <literal>delete-orphan</literal>ì€ ì˜¤ì§ one-to-many 연관들ì—만 ì ìš©ë˜ê³ , <literal>delete()</literal> 오í¼ë ˆì´ì…˜ì´ ê·¸ 연관으로부터 ì œê±°ë˜ëŠ” ìž„ì˜ì˜ ìžì‹ ê°ì²´ì— ì ìš©ë˜ì–´ì•¼ í•¨ì„ ë‚˜íƒ€ë‚¸ë‹¤."
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr "권장사í•ë“¤ :"
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr "í•˜ë‚˜ì˜ <literal><many-to-one></literal> ë˜ëŠ” <literal><many-to-many></literal> ì—°ê´€ì— ëŒ€í•´ 케스케ì´ë“œë¥¼ 가능하게 하는 ê²ƒì€ ëŒ€ê°œ ì˜ë¯¸ê°€ 없다. 케스케ì´ë“œëŠ” <literal><one-to-one></literal> 연관과 <literal><one-to-many></literal> ì—°ê´€ì— ëŒ€í•´ 종종 ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr "ë§Œì¼ ìžì‹ ê°ì²´ì˜ ìˆ˜ëª…ì´ ê·¸ 부모 ê°ì²´ì˜ ìˆ˜ëª…ì— ë¬¶ì—¬ì ¸ ìžˆì„ ê²½ìš°, <literal>cascade=\"all,delete-orphan\"</literal>ì„ ì§€ì •í•¨ìœ¼ë¡œì¨ ê·¸ê²ƒì„ <emphasis>ìƒëª… 주기 ê°ì²´</emphasis>ë¡œ 만들어ë¼."
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr "ê·¸ ë°–ì˜ ê²½ìš°, ë‹¹ì‹ ì€ ì¼€ìŠ¤ì¼€ì´ë“œë¥¼ ì „í˜€ 필요로 하지 ì•Šì„ ìˆ˜ 있다. 그러나 ë§Œì¼ ë‹¹ì‹ ì´ ë™ì¼í•œ 트랜ìžì…˜ ë‚´ì—ì„œ 부모와 ìžì‹ì— 대해 ìžì£¼ 함께 작업하게 ë 것ì´ë¼ ìƒê°ë˜ê³ , ë‹¹ì‹ ìŠ¤ìŠ¤ë¡œ 타ì´í•‘ 하는 ê²ƒì„ ì ˆì•½í•˜ê³ ìž ì›í• 경우, <literal>cascade=\"persist,merge,save-update\"</literal>를 사용하는 ê²ƒì„ ê³ ë ¤í•˜ë¼."
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr "<literal>cascade=\"all\"</literal>ì„ ê°€ì§„ (ë‹¨ì¼ ê°’ ì—°ê´€ì´ë“ í•˜ë‚˜ì˜ ì½œë ‰ì…˜ì´ë“ ) í•˜ë‚˜ì˜ ì—°ê´€ì„ ë§¤í•‘ì‹œí‚¤ëŠ” ê²ƒì€ ê·¸ ì—°ê´€ì„ ë¶€ëª¨ì˜ ì €ìž¥/ì—…ë°ì´íŠ¸/ì‚ì œê°€ ìžì‹ ë˜ëŠ” ìžì‹ë“¤ì˜ ì €ìž¥/ì—…ë°ì´íŠ¸/ì‚ì œë¡œ 귀결ë˜ëŠ” <emphasis>부모/ìžì‹</emphasis> 스타ì¼ì˜ 관계로 마í¬í•œë‹¤."
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr "게다가, í•˜ë‚˜ì˜ ì˜ì† 부모로부터 í•˜ë‚˜ì˜ ìžì‹ì— 대한 단순한 참조는 ìžì‹ì˜ ì €ìž¥/ì—…ë°ì´íŠ¸ë¡œ 귀결ë 것ì´ë‹¤. 하지만 ì´ ë©”íƒ€í¬ëŠ” ë¶ˆì™„ì „í•˜ë‹¤. ê·¸ê²ƒì˜ ë¶€ëª¨ì— ì˜í•´ 참조 í•´ì œë˜ëŠ” ìžì‹ì€ <literal>cascade=\"delete-orphan\"</literal>으로 ë§¤í•‘ëœ í•˜ë‚˜ì˜ <literal><one-to-many></literal> ì—°ê´€ì˜ ê²½ìš°ë¥¼ ì œì™¸í•˜ë©´, ìžë™ì 으로 ì‚ì œë˜ì§€ <emphasis>않는다</emphasis>. í•˜ë‚˜ì˜ ë¶€ëª¨/ìžì‹ ê´€ê³„ì— ëŒ€í•œ 케스케ì´ë”© 오í¼ë ˆì´ì…˜ì˜ ì •í™•í•œ ì˜ë¯¸ëŠ” 다ìŒê³¼ 같다:"
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr "ë§Œì¼ ë¶€ëª¨ê°€ <literal>persist()</literal>ì— ì „ë‹¬ë 경우, ëª¨ë“ ìžì‹ë“¤ì´ <literal>persist()</literal>ì— ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr "ë§Œì¼ ë¶€ëª¨ê°€ <literal>merge()</literal>ì— ì „ë‹¬ë 경우, ëª¨ë“ ìžì‹ë“¤ì´ <literal>merge()</literal>ì— ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr "ë§Œì¼ ë¶€ëª¨ê°€ <literal>save()</literal>, <literal>update()</literal> ë˜ëŠ” <literal>saveOrUpdate()</literal>ì— ì „ë‹¬ë 경우, ëª¨ë“ ìžì‹ë“¤ì´ <literal>saveOrUpdate()</literal>ì— ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr "ë§Œì¼ transient ë˜ëŠ” detached ìžì‹ì´ ì˜ì† ë¶€ëª¨ì— ì˜í•´ 참조ë 경우, ê·¸ê²ƒì€ <literal>saveOrUpdate()</literal>ì— ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr "ë§Œì¼ ë¶€ëª¨ê°€ ì‚ì œë 경우, ëª¨ë“ ìžì‹ë“¤ì´ <literal>delete()</literal>ì— ì „ë‹¬ëœë‹¤"
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr "ë§Œì¼ ìžì‹ì´ ì˜ì† ë¶€ëª¨ì— ì˜í•´ 참조 í•´ì œ ë 경우, <literal>cascade=\"delete-orphan\"</literal>ì´ ì•„ë‹Œ í•œ, <emphasis>특별한 ì–´ë–¤ ê²ƒë„ ë°œìƒí•˜ì§€ 않는다</emphasis> - 어플리케ì´ì…˜ì€ 필요한 ê²½ìš°ì— ìžì‹ì„ 명시ì 으로 ì‚ì œí•´ì•¼ 한다 -, <literal>cascade=\"delete-orphan\"</literal>ì¸ ê²½ìš°ì— \"orphaned(ê³ ì•„)\"ì¸ ê²½ìš° ìžì‹ì´ ì‚ì œëœë‹¤."
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr "마지막으로 오í¼ë ˆì´ì…˜ë“¤ì˜ 케스케ì´ë”©ì´ <emphasis>호출 ì‹œì </emphasis>ì—ì„œ ë˜ëŠ” <emphasis>flush ì‹œì </emphasis>ì—ì„œ ê°ì²´ ê·¸ëž˜í”„ì— ì ìš©ë 수 있ìŒì„ 노트하ë¼. ì´ìš© ê°€ëŠ¥í• ê²½ìš°ì— ëª¨ë“ ì˜¤í¼ë ˆì´ì…˜ë“¤ì€ ê·¸ 오í¼ë ˆì´ì…˜ì´ 실행ë ë•Œ ë„달 가능한 ì—°ê´€ëœ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ 케스케ì´ë“œ ëœë‹¤. 하지만 <literal>save-upate</literal>와 <literal>delete-orphan</literal>ì€ <literal>Session</literal>ì˜ flush ë™ì•ˆì— ë„달 가능한 ëª¨ë“ ì—°ê´€ëœ ì—”í‹°í‹°ë“¤ì— ëŒ€í•´ ì´í–‰ì (transitive)ì´ë‹¤."
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr "메타ë°ì´í„° 사용하기"
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr "Hibernate는 ëª¨ë“ ì—”í‹°í‹°ì™€ ê°’(value) íƒ€ìž…ë“¤ì„ ê°€ì§„ 매우 í’부한 메타-ë ˆë²¨ ëª¨í˜•ì„ í•„ìš”ë¡œ 한다. ì‹œê°„ì´ ì§€ë‚¨ì— ë”°ë¼, ì´ ëª¨í˜•ì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ ê·¸ ìžì²´ì— 매우 ìœ ìš©í•˜ë‹¤. 예를 들어, 어플리케ì´ì…˜ì€ ì–´ëŠ ê°ì²´ë“¤ì´ 복사ë˜ì–´ì•¼ 하는지(예를 들면 가변ì ì¸ ê°’(value) 타입들) ê·¸ë¦¬ê³ ì–´ëŠ ê²ƒì´ ë³µì‚¬ë˜ì§€ ë§ì•„야 하는지(예를 들면, ë¶ˆë³€ì˜ value 타입들과 가능한 ì—°ê´€ëœ ì—”í‹°í‹°ë“¤)를 ì¸ì§€í•˜ëŠ” \"스마트\" deep-copy ì•Œê³ ë¦¬ì¦˜ì„ êµ¬í˜„í•˜ëŠ”ë° Hibernateì˜ ë©”íƒ€ë°ì´í„°ë¥¼ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr "Hibernate는 <literal>ClassMetadata</literal> ì¸í„°íŽ˜ì´ìŠ¤ì™€ <literal>CollectionMetadata</literal> ì¸í„°íŽ˜ì´ìŠ¤ ê·¸ë¦¬ê³ <literal>Type</literal> 계층구조를 통해 메타ë°ì´í„°ë¥¼ 노출시킨다. 메타ë°ì´í„° ì¸í„°íŽ˜ì´ìŠ¤ë“¤ì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ <literal>SessionFactory</literal>로부터 얻어질 ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,744 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr "ë„구셋 안내"
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr "Hibernateì— ëŒ€í•œ ë¼ìš´ë“œíŠ¸ë¦½ 엔지니어ë§ì€ Eclipse í”ŒëŸ¬ê·¸ì¸ ì„¸íŠ¸, ëª…ë ¹ë¼ì¸ ë„구들, ë¿ë§Œ ì•„ë‹ˆë¼ Ant 태스í¬ë“¤ì„ 사용하여 가능하다."
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "<emphasis>Hibernate ë„구들</emphasis>ì€ í˜„ìž¬ 기존 ë°ì´í„°ë² ì´ìŠ¤ë“¤ì— 대한 리버스 엔지니어ë§ì„ 위해 Ant 태스í¬ë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ Eclipse IDEìš© 플러그ì¸ë“¤ì„ í¬í•¨í•˜ê³ 있다:"
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr "<emphasis>매핑 편집기:</emphasis> ìžë™ 완성 기능과 구문 강조를 지ì›í•˜ëŠ” Hibernate XML 매핑 파ì¼ë“¤ì— 대한 편집기. ê·¸ê²ƒì€ ë˜í•œ 통ìƒì˜ XML 편집기 보다 훨씬 ë” ìœµí†µì„± 있게 만들어서 í´ëž˜ìŠ¤ ì´ë¦„들과 프로í¼í‹°/í•„ë“œ ì´ë¦„ë“¤ì— ëŒ€í•œ ì˜ë¯¸ë¡ ì ìžë™ 완성 ê¸°ëŠ¥ì„ ì§€ì›í•œë‹¤."
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>콘솔:</emphasis> ì½˜ì†”ì€ Eclipseì—ì„œ 새로운 ë·°ì´ë‹¤. ë‹¹ì‹ ì˜ ì½˜ì†” êµ¬ì„±ë“¤ì— ëŒ€í•œ tree overviewì— ë§ë¶™ì—¬, ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì˜ ì˜ì† í´ëž˜ìŠ¤ë“¤ê³¼ ê·¸ê²ƒë“¤ì˜ ê´€ê³„ë“¤ì— ëŒ€í•œ ìƒí˜¸ìž‘ìš© 뷰를 얻는다. ì½˜ì†”ì€ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ì— 대해 HQL 질ì˜ë“¤ì„ ì‹¤í–‰í•˜ê³ ê·¸ 결과를 Eclipse ë‚´ì—ì„œ ì§ì ‘ 브ë¼ìš°ì§• 하ë„ë¡ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>개발 마법사들:</emphasis> 몇몇 ë§ˆë²•ì‚¬ë“¤ì´ Hibernate Eclipse ë„êµ¬ë“¤ì— ì œê³µëœë‹¤; ë‹¹ì‹ ì€ Hibernate 구성 (cfg.xml) 파ì¼ë“¤ì„ ë¹ ë¥´ê²Œ ìƒì„±ì‹œí‚¤ëŠ”ë° ë§ˆë²•ì‚¬ë¥¼ 사용하거나, 심지어 ë‹¹ì‹ ì€ ê¸°ì¡´ ë°ì´í„°ë² ì´ìŠ¤ 스키마를 POJO 소스 파ì¼ë“¤ê³¼ Hibernate 매핑 파ì¼ë“¤ë¡œ ì™„ì „í•˜ê²Œ 리버스 엔지니어ë§í• ìˆ˜ë„ ìžˆë‹¤. 리버스 ì—”ì§€ë‹ˆì–´ë§ ë§ˆë²•ì‚¬ëŠ” 맞춤 가능한 í…œí”Œë¦¿ë“¤ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr "Ant 태스í¬ë“¤:"
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr "추가 ì •ë³´ëŠ” <emphasis>Hibernate Tools</emphasis> 패키지와 ê·¸ê²ƒì˜ ë¬¸ì„œë¥¼ 참조하길 바란다."
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr "하지만 Hibernate ë©”ì¸ íŒ¨í‚¤ì§€ëŠ” 통합 ë„êµ¬ì— ë²ˆë“¤í™” ë˜ì–´ 있다(ê·¸ê²ƒì€ ì‹¬ì§€ì–´ 플ë¼ì´ ìƒì—ì„œ Hibernate \"ë‚´ì—ì„œ\" 사용ë 수 있다): <emphasis>SchemaExport</emphasis> 별ì¹ì€ <literal>hbm2ddl</literal>."
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr "ìžë™ì ì¸ ìŠ¤í‚¤ë§ˆ ìƒì„±"
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "DDLì€ Hibernate ìœ í‹¸ë¦¬í‹°ì— ì˜í•´ ë‹¹ì‹ ì˜ ë§¤í•‘ 파ì¼ë“¤ë¡œë¶€í„° ìƒì„±ë 수 있다. ìƒì„±ëœ 스키마는 엔티티 í…Œì´ë¸”ê³¼ ì½œë ‰ì…˜ í…Œì´ë¸”ì— ëŒ€í•œ 참조 무결성 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë“¤(프ë¼ì´ë¨¸ë¦¬ 키와 foreign 키들)ì„ í¬í•¨í•œë‹¤. í…Œì´ë¸”들과 ì‹œí€€ìŠ¤ë“¤ì€ ë˜í•œ 페ì¹ëœ ì‹ë³„ìž ìƒì„±ê¸°ë“¤ì— 대해 ìƒì„±ëœë‹¤."
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr "DDLì´ ë§¤ìš° 벤ë”ì— íŠ¹ì •í•˜ë¯€ë¡œ, ì´ ë„구를 ì‚¬ìš©í• ë•Œ ë‹¹ì‹ ì€ <literal>hibernate.dialect</literal> 프로í¼í‹°ë¥¼ 통해 í•œ ê°œì˜ SQL <literal>Dialect</literal>를 ì§€ì •<emphasis>해야 한다</emphasis>."
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr "ë¨¼ì € ìƒì„±ëœ 스키마를 ê°œì„ ì‹œí‚¤ê¸° 위해 ë‹¹ì‹ ì˜ ë§¤í•‘ 파ì¼ë“¤ì„ 맞춤화 시켜ë¼."
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr "스키마 맞춤화 시키기"
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr "ë§Žì€ Hibernate 매핑 ìš”ì†Œë“¤ì€ <literal>length</literal>ë¡œ ëª…ëª…ëœ ì˜µì…˜ ì†ì„±ì„ ì •ì˜í•œë‹¤. ë‹¹ì‹ ì€ ì´ ì†ì„±ìœ¼ë¡œ ì»¬ëŸ¼ì˜ ê¸¸ì´ë¥¼ ì„¤ì •í• ìˆ˜ 있다.(ë˜ëŠ” numeric/decimal ë°ì´í„° 타입들, ë°°ì •ë„ì— ëŒ€í•´ ). ë§Žì€ Hibernate ë§¤ì¹ ìš”ì†Œë“¤ì€ <literal>length</literal>, <literal>precision</literal> ê·¸ë¦¬ê³ <literal>scale</literal>ë¡œ ëª…ëª…ëœ ì˜µì…˜ ì†ì„±ë“¤ì„ ì •ì˜í•˜ê³ 있다. ë‹¹ì‹ ì€ ì´ ì†ì„±ìœ¼ë¡œì„œ ì»¬ëŸ¼ì´ ê¸¸ì´, ì •ë°€ë„, í¬ê¸°ë¥¼ ì„¤ì •í• ìˆ˜ 있다."
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr "몇몇 íƒœê·¸ë“¤ì€ ë˜í•œ (í…Œì´ë¸” ì»¬ëŸ¼ë“¤ì— ëŒ€í•œ <literal>NOT NULL</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìƒì„±ì‹œí‚¤ëŠ”) <literal>not-null</literal> ì†ì„±ê³¼ (í…Œì´ë¸” ì»¬ëŸ¼ë“¤ì— ëŒ€í•œ <literal>UNIQUE</literal> ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìƒì„±ì‹œí‚¤ëŠ”) <literal>unique</literal> ì†ì„±ì„ 수용한다."
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr "<literal>unique-key</literal> ì†ì„±ì€ í•˜ë‚˜ì˜ ìœ ì¼ í‚¤ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¡œ ì»¬ëŸ¼ë“¤ì„ ê·¸ë£¹ì§€ìš°ëŠ”ë° ì‚¬ìš©ë ìˆ˜ë„ ìžˆë‹¤. 현재 <literal>unique-key</literal> ì†ì„±ì˜ ì§€ì •ëœ ê°’ì€ ì‚°ì¶œëœ DDLë‚´ì—ì„œ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ëª…ëª…í•˜ëŠ”ë° ì‚¬ìš©ë˜ì§€ <emphasis>ì•Šê³ </emphasis>, ì˜¤ì§ ë§¤í•‘ íŒŒì¼ ë‚´ì—ì„œ ì»¬ëŸ¼ë“¤ì„ ê·¸ë£¹ ì§€ìš°ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr "<literal>index</literal> ì†ì„±ì€ ë§¤í•‘ëœ ì»¬ëŸ¼ ë˜ëŠ” ì»¬ëŸ¼ë“¤ì„ ì‚¬ìš©í•˜ì—¬ ìƒì„±ë ì¸ë±ìŠ¤ì˜ ì´ë¦„ì„ ì§€ì •í•œë‹¤. 간단하게 ë™ì¼í•œ ì¸ë±ìŠ¤ ì´ë¦„ì„ ì§€ì •í•¨ìœ¼ë¡œì¨ ì—¬ëŸ¬ ì»¬ëŸ¼ë“¤ì´ ë™ì¼í•œ ì¸ë±ìŠ¤ ë‚´ë¡œ 그룹지워질 ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr "<literal>foreign-key</literal> ì†ì„±ì€ ìž„ì˜ì˜ ì‚°ì¶œëœ foreign 키 ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ ì´ë¦„ì„ ì˜¤ë²„ë¼ì´ë“œ ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë 수 ë„ ìžˆë‹¤."
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "ë§Žì€ ë§¤í•‘ ìš”ì†Œë“¤ì€ ë˜í•œ í•˜ë‚˜ì˜ ìžì‹ <literal><column></literal> 요소를 허용한다. ì´ê²ƒì€ 특히 다중 컬럼 íƒ€ìž…ë“¤ì„ ë§¤í•‘í•˜ëŠ”ë° ìœ ìš©í•˜ë‹¤:"
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr "다른 방법으로, ì´ë“¤ ìš”ì†Œë“¤ì€ ë˜í•œ ìžì‹ <literal><column></literal> 요소를 수용한다. ì´ê²ƒì€ 다중 컬럼 íƒ€ìž…ë“¤ì— íŠ¹ížˆ ìœ ìš©í•˜ë‹¤: <literal>default</literal> ì†ì„±ì€ ë‹¹ì‹ ìœ¼ë¡œ 하여금 í•˜ë‚˜ì˜ ì»¬ëŸ¼ì— ëŒ€í•œ ë””í´íŠ¸ ê°’ì„ ì„¤ì •í•˜ë„ë¡ í•œë‹¤(ë‹¹ì‹ ì€ ë§¤í•‘ëœ í´ëž˜ìŠ¤ì˜ 새로운 ì¸ìŠ¤í„´ìŠ¤ë¥¼ ì €ìž¥í•˜ê¸° ì „ì— ë§¤í•‘ëœ í”„ë¡œí¼í‹°ì— ë™ì¼í•œ ê°’ì„ í• ë‹¹í•˜ê²Œ ë 것ì´ë‹¤)."
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "<literal>sql-type</literal> ì†ì„±ì€ SQL ë°ì´í„°íƒ€ìž…ì— ëŒ€í•œ Hibernate íƒ€ìž…ì˜ ë””í´íŠ¸ ë§¤í•‘ì„ ì˜¤ë²„ë¼ì´ë“œ 시키는 ê²ƒì„ ì‚¬ìš©ìžì—게 허용해준다."
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr "<literal>check</literal> ì†ì„±ì€ check ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ì§€ì •í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Summary"
+msgstr "<title>요약</title>"
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr "<entry>ì†ì„±</entry>"
+
+#: index.docbook:164
+msgid "Values"
+msgstr "<entry>값들</entry>"
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr "<entry>í•´ì„</entry>"
+
+#: index.docbook:170
+msgid "length"
+msgstr "length"
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr "number"
+
+#: index.docbook:172
+msgid "column length"
+msgstr "컬럼 길ì´"
+
+#: index.docbook:175
+msgid "precision"
+msgstr "precision"
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr "컬럼 decimal ì •ë°€ë„"
+
+#: index.docbook:180
+msgid "scale"
+msgstr "scale"
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr "컬럼 decimal í¬ê¸°"
+
+#: index.docbook:185
+msgid "not-null"
+msgstr "not-null"
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr "true|false"
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr "ì»¬ëŸ¼ì´ nullì´ ì•„ë‹ˆì–´ì•¼ í•¨ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:190
+msgid "unique"
+msgstr "unique"
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr "ì»¬ëŸ¼ì´ í•˜ë‚˜ì˜ ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ê°€ì ¸ì•¼í•¨ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:195
+msgid "index"
+msgstr "index"
+
+#: index.docbook:196
+msgid "index_name"
+msgstr "index_name"
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr "(다중-컬럼) ì¸ë±ìŠ¤ì˜ ì´ë¦„ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr "unique-key"
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr "unique_key_name"
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr "다중-컬럼 ìœ ì¼ ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ ì´ë¦„ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr "foreign-key"
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr "foreign_key_name"
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "í•˜ë‚˜ì˜ ì—°ê´€ì— ëŒ€í•´, <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, ë˜ëŠ” <literal><many-to-many></literal> 매핑 ìš”ì†Œì— ëŒ€í•´ foreign key ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ì˜ ì´ë¦„ì„ ì§€ì •í•œë‹¤.<literal>inverse=\"true\"</literal> ì¸¡ë“¤ì€ <literal>SchemaExport</literal>ì— ì˜í•´ ê³ ë ¤ë˜ì§€ ì•Šì„ ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr "sql-type"
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr "SQL column type"
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr "ë””í´íŠ¸ 컬럼 íƒ€ìž…ì„ ì˜¤ë²„ë¼ì´ë“œ 시킨다 (<literal><column></literal> ìš”ì†Œì˜ ì†ì„±ì—만)"
+
+#: index.docbook:225
+msgid "default"
+msgstr "default"
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr "SQL expression"
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr "ì»¬ëŸ¼ì— ëŒ€í•œ ë””í´íŠ¸ ê°’ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:232
+msgid "check"
+msgstr "check"
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr "컬럼 ë˜ëŠ” í…Œì´ë¸”ì— ëŒ€í•œ SQL check ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ë¥¼ ìƒì„±ì‹œí‚¨ë‹¤"
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr "<literal><comment></literal> 요소는 ìƒì„±ëœ ìŠ¤í‚¤ë§ˆì— ëŒ€í•œ 주ì„ë“¤ì„ ì§€ì •í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다."
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr "ì´ê²ƒì€ (지ì›ë˜ëŠ” 경우) ìƒì„±ëœ DDLì—ì„œ <literal>comment on table</literal> ë˜ëŠ” <literal>comment on column</literal> 문장으로 귀결ëœë‹¤."
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr "ë„구 실행하기"
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "<literal>SchemaExport</literal> ë„구는 DDL 스í¬ë¦½íŠ¸ë¥¼ 표준 ì¶œë ¥ìœ¼ë¡œ ê¸°ë¡ í•˜ê³ /하거나 DDL ë¬¸ìž¥ë“¤ì„ ì‹¤í–‰ì‹œí‚¨ë‹¤."
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr "<literal>SchemaExport</literal> ëª…ë ¹ ë¼ì¸ 옵션들"
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr "<entry>옵션</entry>"
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr "<entry>설명</entry>"
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr "--quiet"
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr "스í¬ë¦½íŠ¸ë¥¼ í‘œì¤€ì¶œë ¥ìœ¼ë¡œ ì¶œë ¥í•˜ì§€ 않는다"
+
+#: index.docbook:289
+msgid "--drop"
+msgstr "--drop"
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr "ì˜¤ì§ í…Œì´ë¸”ë“¤ì„ ë“œë¡ì‹œí‚¨ë‹¤"
+
+#: index.docbook:293
+msgid "--create"
+msgstr "--create"
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr "ì˜¤ì§ í…Œì´ë¸”ë“¤ì„ ìƒì„±ì‹œí‚¨ë‹¤"
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr "--text"
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ë¡œ 내보내기 하지 않는다"
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr "--output=my_schema.ddl"
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr "ddl 스í¬ë¦½íŠ¸ë¥¼ 파ì¼ë¡œ ì¶œë ¥í•œë‹¤"
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr "--naming=eg.MyNamingStrategy"
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr "í•˜ë‚˜ì˜ <literal>NamingStrategy</literal>를 ì„ íƒí•œë‹¤"
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr "--config=hibernate.cfg.xml"
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr "XML 파ì¼ë¡œë¶€í„° Hibernate êµ¬ì„±ì„ ì½ì–´ë“¤ì¸ë‹¤"
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr "파ì¼ë¡œë¶€í„° ë°ì´í„°ë² ì´ìŠ¤ 프로í¼í‹°ë“¤ì„ ì½ì–´ë“¤ì¸ë‹¤"
+
+#: index.docbook:317
+msgid "--format"
+msgstr "--format"
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr "ìƒì„±ëœ SQLì„ ìŠ¤í¬ë¦½íŠ¸ ë‚´ì— ì¢‹ê²Œ 형ì‹ì§€ìš´ë‹¤"
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr "--delimiter=;"
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr "스í¬ë¦½íŠ¸ë¥¼ 위한 ë¼ì¸ ê²½ê³„ì˜ ëì„ ì„¤ì •í•œë‹¤"
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr "ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì— <literal>SchemaExport</literal>를 삽입시킬 ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+
+#: index.docbook:337
+msgid "Properties"
+msgstr "프로í¼í‹°ë“¤"
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ 프로í¼í‹°ë“¤ì€ 다ìŒê³¼ ê°™ì´ ì§€ì •ë 수 있다"
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "<literal>-D</literal><emphasis><property></emphasis>를 가진 시스템 프로í¼í‹°ë¡œì„œ"
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr "<literal>hibernate.properties</literal> ë‚´ì—ì„œ"
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr "<literal>--properties</literal>를 가진 ëª…ëª…ëœ í”„ë¡œí¼í‹°ë“¤ ë‚´ì—ì„œ"
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr "필요한 프로í¼í‹°ë“¤ì€ 다ìŒê³¼ 같다:"
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr "SchemaExport 커넥션 프로í¼í‹°ë“¤"
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr "프로í¼í‹° ì´ë¦„"
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr "jdbc ë“œë¼ì´ë²„ í´ëž˜ìŠ¤"
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr "jdbc url"
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:381
+msgid "database user"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ 사용ìž"
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:385
+msgid "user password"
+msgstr "ì‚¬ìš©ìž íŒ¨ìŠ¤ì›Œë“œ"
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:389
+msgid "dialect"
+msgstr "dialect"
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr "Ant 사용하기"
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr "ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ Ant 빌드 스í¬ë¦½íŠ¸ì—ì„œ <literal>SchemaExport</literal>를 í˜¸ì¶œí• ìˆ˜ 있다:"
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr "ì ì¦í•˜ëŠ” 스키마 ì—…ë°ì´íŠ¸ë“¤"
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr "<literal>SchemaUpdate</literal> ë„구는 \"ì ì¦í•˜ëŠ”\" ë³€ê²½ë“¤ì„ ê°€ì§„ 기존 스키마를 변경시킬 것ì´ë‹¤. <literal>SchemaUpdate</literal>는 JDBC 메타ë°ì´í„° APIì— ë¬´ê²ê²Œ ì˜ì¡´í•˜ì—¬ì„œ, ê·¸ê²ƒì€ ëª¨ë“ JDBC ë“œë¼ì´ë²„ë“¤ì— ë™ìž‘하지 ì•Šì„ ê²ƒìž„ì„ ì£¼ëª©í•˜ë¼."
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr "<literal>SchemaUpdate</literal> ëª…ë ¹ ë¼ì¸ 옵션들"
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr "스í¬ë¦½íŠ¸ë¥¼ ë°ì´í„°ë² ì´ìŠ¤ë¡œ 내보내기 하지 않는다"
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr "<literal>.cfg.xml</literal> 파ì¼ì„ ì§€ì •í•œë‹¤"
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr "ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì— <literal>SchemaUpdate</literal>를 삽입시킬 수 있다:"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr "ì ì¦í•˜ëŠ” 스키마 ì—…ë°ì´íŠ¸ë“¤ì— Ant 사용하기"
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr "ë‹¹ì‹ ì€ Ant 스í¬ë¦½íŠ¸ì—ì„œ<literal>SchemaUpdate</literal>를 í˜¸ì¶œí• ìˆ˜ 있다:"
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr "스키마 ìœ íš¨ì„± 검사"
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr "<literal>SchemaValidator</literal> ë„구는 ê¸°ì¡´ì˜ ë°ì´í„°ë² ì´ìŠ¤ 스키마가 ë‹¹ì‹ ì˜ ë§¤í•‘ 문서들과 \"ì¼ì¹˜í•˜ëŠ”지\"를 ìœ íš¨ì„± ê²€ì‚¬í• ê²ƒì´ë‹¤. <literal>SchemaValidator</literal>ê°€ JDBC 메타ë°ì´í„° APIì— ë¬´ê²ê²Œ ì˜ì¡´í•˜ë¯€ë¡œ ê·¸ê²ƒì€ ëª¨ë“ JDBC ë“œë¼ì´ë²„ë“¤ì— ëŒ€í•´ ë™ìž‘하지 ì•Šì„ ê²ƒì´ë‹¤. ì´ ë„구는 í…ŒìŠ¤íŒ…ì— ê·¹ížˆ ìœ ìš©í•˜ë‹¤."
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr "<literal>SchemaValidator</literal> ëª…ë ¹ ë¼ì¸ 옵션들"
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr "ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì— <literal>SchemaValidator</literal>ì„ ì‚½ìž…ì‹œí‚¬ 수 ë„ ìžˆë‹¤:"
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr "스키마 ìœ íš¨ì„± 검사를 위해 Ant 사용하기"
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr "ë‹¹ì‹ ì€ Ant 스í¬ë¦½íŠ¸ì—ì„œ <literal>SchemaValidator</literal>를 í˜¸ì¶œí• ìˆ˜ 있다:"
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,790 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr "트랜ìžì…˜ë“¤ê³¼ ë™ì‹œì„±"
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "Hibernate와 ë™ì‹œì„± ì œì–´ì— ëŒ€í•œ 가장 중요한 ì ì€ ì´í•´í•˜ê¸°ê°€ 매우 쉽다는 ì ì´ë‹¤. Hibernate는 ì–´ë–¤ 추가ì ì¸ ìž ê¸ˆ 행위 ì—†ì´ JDBC 커넥션들과 JTA ë¦¬ì†ŒìŠ¤ë“¤ì„ ì§ì ‘ 사용한다. 우리는 ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ 관리 ì‹œìŠ¤í…œì˜ JDBC, ANSI, ê·¸ë¦¬ê³ íŠ¸ëžœìžì…˜ 격리 ëª…ì„¸ì— ì•½ê°„ì˜ ì‹œê°„ì„ í• ì• í• ê²ƒì„ ë§¤ìš° 권장한다."
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr "Hibernate는 메모리 ë‚´ì—ì„œ ê°ì²´ë“¤ì„ ìž ê·¸ì§€ 않는다. ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì€ 격리 ë ˆë²¨ì— ì˜í•´ ì •ì˜ëœ 대로 행위를 ê¸°ëŒ€í• ìˆ˜ 있다. ë˜í•œ transaction-ì˜ì—ì˜ ìºì‹œì¸ <literal>Session</literal> ë•ë¶„ì—, Hibernate는 (ìŠ¤ì¹¼ë¼ ê°’ë“¤ì„ ë°˜í™˜í•˜ëŠ” 질ì˜ë“¤ì„ ë³´ê³ í•˜ì§€ 않는) ì‹ë³„ìžì™€ 엔티티 질ì˜ë“¤ì— ì˜í•œ ë£©ì—…ì„ ìœ„í•´ 반복 가능한 ì½ê¸°ë¥¼ ì œê³µí•œë‹¤."
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "ìžë™ì ì¸ optimistic ë™ì‹œì„± ì œì–´ë¥¼ 위한 ë²„ì „í™”ì— ë§ë¶™ì—¬, Hibernate는 ë˜í•œ <literal>SELECT FOR UPDATE</literal> êµ¬ë¬¸ì„ ì‚¬ìš©í•˜ì—¬ í–‰ë“¤ì— ëŒ€í•œ pessimistic ìž ê¸ˆì„ ìœ„í•œ í•˜ë‚˜ì˜ (마ì´ë„ˆ)API를 ì œê³µí•œë‹¤. optimistic ë™ì‹œì„± ì œì–´ì™€ ì´ API는 ì´ ìž¥ì˜ ë’·ë¶€ë¶„ì—ì„œ ë…¼ì˜ëœë‹¤."
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "우리는 <literal>Configuration</literal>, <literal>SessionFactory</literal>, <literal>Session</literal>, 알갱ì´ë¥¼ 가진 Hibernateì—ì„œì˜ ë™ì‹œì„± ì œì–´ ë¿ë§Œ ì•„ë‹ˆë¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ê³¼ ìž¥ê¸°ê°„ì— ê±¸ì¹œ (컴퓨터와ì˜)ëŒ€í™”ë“¤ì— ëŒ€í•œ ë…¼ì˜ë¥¼ 시작한다."
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr "세션 ì˜ì—ê³¼ 트랜ìžì…˜ ì˜ì—"
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "<literal>SessionFactory</literal>는 ëª¨ë“ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì“°ë ˆë“œë“¤ì— ì˜í•´ ê³µìœ ë˜ë„ë¡ ê³ ì•ˆëœ ìƒì„±ì— ë¹„ìš©ì´ ë“œëŠ”, ì“°ë ˆë“œì•ˆì „(threadsafe) ê°ì²´ì´ë‹¤. ê·¸ê²ƒì€ ëŒ€ê°œ 어플리케ì´ì…˜ 시작 ì‹œì— <literal>Configuration</literal> ì¸ìŠ¤í„´ìŠ¤ë¡œë¶€í„° 한번 ìƒì„±ëœë‹¤."
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr "<literal>Session</literal>ì€ í•˜ë‚˜ì˜ ìš”ì², í•˜ë‚˜ì˜ ëŒ€í™” , í•˜ë‚˜ì˜ ìž‘ì—… 단위를 위해 한번만 사용ë˜ê³ 나서 í기ë ì˜ˆì •ì¸, ë¹„ìš©ì´ ë“¤ì§€ 않는, ì“°ë ˆë“œ ì•ˆì „í•˜ì§€ ì•Šì€ ê°ì²´ì´ë‹¤. <literal>Session</literal>ì€ ì»¤ë„¥ì…˜ì´ í•„ìš”í•˜ì§€ 않으면 í•˜ë‚˜ì˜ JDBC <literal>Connection</literal>(ë˜ëŠ” <literal>Datasource</literal>)를 얻지 ì•Šì„ ê²ƒì´ë¯€ë¡œ, 사용ë 때까지 ë¦¬ì†ŒìŠ¤ë“¤ì„ ì†Œë¹„í•˜ì§€ 않는다."
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr "ì´ ê·¸ë¦¼ì„ ì™„ì„±í•˜ê¸° 위해 ë‹¹ì‹ ì€ ë˜í•œ ë°ì´í„°ë² ì´ìŠ¤ íŠ¸ëžœìž¬ì…˜ë“¤ì— ëŒ€í•´ ìƒê°í•´ì•¼ 한다. ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì€ ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ìž ê¸ˆ ë‹¤íˆ¼ì„ ì¤„ì´ê¸° 위해 가능한 짧아야 한다. 긴 ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ê³ ë„ì˜ ë™ì‹œì„± ë¡œë“œë¡œì˜ ê°€ìš©ì„±ì„ ë†’ì´ëŠ” ê²ƒì„ ë°©í•´í• ê²ƒì´ë‹¤. 그러므로 사용ìžê°€ ìƒê°í•˜ëŠ” 시간 ë™ì•ˆ 단위 ìž‘ì—…ì´ ì™„ë£Œë 때까지 ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ ì—´ë ¤ì§„ì±„ë¡œ ì†Œìœ í•˜ëŠ” ê²ƒì€ ëŒ€ê°œ ê²°ì½” ì¢‹ì€ ì„¤ê³„ëŠ” 아니다."
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr "í•˜ë‚˜ì˜ ìž‘ì—… ë‹¨ìœ„ì˜ ì˜ì—ì€ ë¬´ì—‡ì¸ê°€? í•˜ë‚˜ì˜ Hibernate <literal>Session</literal>ì€ ëª‡ëª‡ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì— ê±¸ì¹ ìˆ˜ 있는가 ë˜ëŠ” ì´ê²ƒì€ ì˜ì—ë“¤ì˜ one-to-one 관계ì¸ê°€? ë‹¹ì‹ ì€ ì–¸ì œ <literal>Session</literal>ì„ ì—´ê³ ë‹«ëŠ”ê°€ ê·¸ë¦¬ê³ ë‹¹ì‹ ì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ ê²½ê³„ë“¤ì„ ì–´ë–»ê²Œ í•œì •í•˜ëŠ”ê°€?"
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr "작업 단위"
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr "첫번째로, <emphasis>session-per-operation</emphasis> anti-íŒ¨í„´ì„ ì‚¬ìš©í•˜ì§€ ë§ë¼. 즉, ë‹¨ì¼ ì“°ë ˆë“œ ë‚´ì—ì„œ ëª¨ë“ ê°„ë‹¨í•œ ë°ì´í„°ë² ì´ìŠ¤ í˜¸ì¶œì— ëŒ€í•´ <literal>Session</literal>ì„ ì—´ê³ ë‹«ì§€ ë§ë¼! ë¬¼ë¡ ê°™ì€ ê²ƒì´ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì— ëŒ€í•´ì„œë„ ì°¸ì´ë‹¤. 어플리케ì´ì…˜ ë‚´ì˜ ë°ì´í„°ë² ì´ìŠ¤ í˜¸ì¶œë“¤ì€ ê³„íšëœ 순서를사용하여 행해지며, ê·¸ê²ƒë“¤ì€ ì›ìž ìž‘ì—… 단위 ì†ìœ¼ë¡œ 그룹지워진다. (ì´ê²ƒì€ ë˜í•œ ëª¨ë“ í•˜ë‚˜ì˜ SQL 문장 ë’¤ì˜ auto-commit(ìžë™-커밋)ì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì—ì„œ ë¬´ìš©ì§€ë¬¼ìž„ì„ ì˜ë¯¸í•˜ê³ , ì´ ëª¨ë“œê°€ SQL 콘솔 ìž‘ì—…ì„ ë•ë„ë¡ ê³ ì•ˆë˜ì—ˆìŒì„ 노트하ë¼. Hibernate는 ì˜ë¯¸í•˜ê³ , ì´ ëª¨ë“œëŠ” Hibernate는 즉시 ìžë™-커밋 모드를 사용 불가능하게 하거나, 어플리케ì´ì…˜ 서버가 ê·¸ë ‡ê²Œ í–‰í•˜ê³ , 즉시 ìžë™-커밋시키는 ê²ƒì„ ì‚¬ìš©ë¶ˆê°€ëŠ¥í•˜ê²Œ 하거나 ,ê·¸ë ‡ê²Œ 행하는 ê²ƒì„ ê¸°ëŒ€í•œë!
‹¤.) ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì€ ê²°ì½” ì˜µì…˜ì´ ì•„ë‹ˆë©°, í•˜ë‚˜ì˜ ë°ì´í„°ë² ì´ìŠ¤ì™€ì˜ ëª¨ë“ í†µì‹ ì€ ë‹¹ì‹ ì´ ë°ì´í„°ë¥¼ ì½ë“ ì“°ë‹¨ê°„ì— ìƒê´€ì—†ì´ í•˜ë‚˜ì˜ íŠ¸ëžœìžì…˜ ë‚´ì—ì„œ ë°œìƒí•´ì•¼ 한다. 설명하였듯ì´, ë°ì´í„° ì½ê¸°ë¥¼ 위한 auto-commit íŠ¹ì§•ì„ í”¼í•´ì•¼ í• ê²ƒì´ë©°, ë§Žì€ ìž‘ì€ íŠ¸ëžœìžì…˜ë“¤ì€ í•˜ë‚˜ì˜ ëª…ë£Œí•˜ê²Œ ì •ì˜ëœ ìž‘ì—… 단위보다 ë” ì¢‹ê²Œ 수행ë 것 같지 않다. 후ìžê°€ ë˜í•œ 훨씬 ë” ìœ ì§€ê°€ëŠ¥í•˜ê³ í™•ìž¥ì ì´ë‹¤."
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "다중 ì‚¬ìš©ìž í´ë¼ì´ì–¸íŠ¸/서버 어플리케ì´ì…˜ì—ì„œ 가장 ê³µí†µëœ íŒ¨í„´ì€ <emphasis>session-per-request</emphasis>ì´ë‹¤. ì´ ëª¨í˜•ì—ì„œ, í´ë¼ì´ì–¸íŠ¸ë¡œë¶€í„°ì˜ ìš”ì²ì€ (Hibernate ì˜ì† ê³„ì¸µì´ ì‹¤í–‰ë˜ëŠ”) 서버로 ì „ì†¡ë˜ê³ , 새로운 Hibernate <literal>Session</literal>ì´ ì—´ë ¤ì§€ê³ , ëª¨ë“ ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ë“¤ì´ ì´ ìž‘ì—… 단위 ë‚´ì—ì„œ 실행ëœë‹¤. ì¼ë‹¨ ê·¸ ìž‘ì—…ì´ ì™„ë£Œë˜ì—ˆë‹¤ë©´(ê·¸ë¦¬ê³ í´ë¼ì´ì–¸íŠ¸ì— 대한 ì‘ë‹µì´ ì¤€ë¹„ë˜ì—ˆë‹¤ë©´), ê·¸ ì„¸ì…˜ì€ flush ë˜ê³ 닫혀진다. ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì´ <literal>Session</literal>ì„ ì—´ê³ ë‹«ì„ ë•Œ ê·¸ê²ƒì„ ì‹œìž‘í•˜ê³ ì»¤ë°‹ì‹œì¼œì„œ í´ë¼ì´ì–¸íŠ¸ ìš”ì²ì— ì„œë¹„ìŠ¤í•˜ëŠ”ë° í•œ ê°œì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 사용하게 ë 것ì´ë‹¤. 둘 사ì´ì˜ 관계는 ì¼ëŒ€ì¼ 대ì‘ì´ê³ ì´ ëª¨í˜•ì€ ë§Žì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì—ì„œ ì™„ì „í•˜ê²Œ ì 합하다."
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr "ë‚œì œëŠ” êµ¬í˜„ì— ë†“ì—¬ìžˆë‹¤: Hibernate는 ì´ íŒ¨í„´ì„ ë‹¨ìˆœí™” 시키기 위해 \"현재 세션\"ì— ê´€í•œ 미리 ë¹Œë“œëœ ê´€ë¦¬ë¥¼ ì œê³µí•œë‹¤. ë‹¹ì‹ ì´ í–‰í•´ì•¼í• ëª¨ë“ ê²ƒì€ ì„œë²„ ìš”ì²ì´ 처리ë˜ì–´ì•¼ í• ë•Œ 트랜ìžì…˜ì„ ì‹œìž‘í•˜ê³ , ê·¸ ì‘ë‹µì´ í´ë¼ì´ì–¸íŠ¸ë¡œ ì „ì†¡ë˜ê¸° ì „ì— íŠ¸ëžœìžì…˜ì„ ë내는 것ì´ë‹¤. ë‹¹ì‹ ì€ ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ìž„ì˜ì˜ 방법으로 ì´ê²ƒì„ í–‰í• ìˆ˜ 있으며, ê³µí†µëœ í•´ê²°ì±…ë“¤ì€ ì„œë¹„ìŠ¤ 메소드들 ìƒì˜ 첨단, ë˜ëŠ” í•˜ë‚˜ì˜ í”„ë½ì‹œ/ì¸í„°ì…‰ì…˜ 컨테ì´ë„ˆë¥¼ 가진 APO ì¸í„°ì…‰í„°ì¸, <literal>ServletFilter</literal>ì´ë‹¤. í•˜ë‚˜ì˜ EJB 컨테ì´ë„ˆëŠ” CMTì˜ ê²½ìš°ì— ì„ ì–¸ì 으로 EJB session beans ìƒì— 트랜ìžì…˜ 경계구분과 ê°™ì€ ë™ì‹œ 대조 ì¸¡ë©´ë“¤ì„ êµ¬í˜„í•˜ëŠ” 표준 방법ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ í”„ë¡œê·¸ëž¨ ìƒì˜ 트랜ìžì…˜ ê²½ê³„êµ¬ë¶„ì„ ì‚¬ìš©í•˜ê³ ìž ê²°ì •í•œë‹¤ë©´, ì‚¬ìš©ì˜ ìš©ì´ì„±ê³¼ 코드 ì´ì‹ì„±ì„ 위해 ì´ ìž¥ì˜ ë’· !
부분ì—ì„œ 보여진 Hibernate <literal>Transaction</literal>ì„ ì„ í˜¸í•˜ë¼."
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr "ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ 코드는 ì–´ë””ì„œë“ í•„ìš”í• ë•Œ 종종 <literal>sessionFactory.getCurrentSession()</literal>ì„ ê°„ë‹¨ížˆ í˜¸ì¶œí•¨ìœ¼ë¡œì¨ ìš”ì²ì„ ì²˜ë¦¬í• \"현재 세션\"ì— ì ‘ê·¼í• ìˆ˜ 있다. ë‹¹ì‹ ì€ í˜„ìž¬ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ìœ¼ë¡œ ì˜ì—í™”ëœ í•˜ë‚˜ì˜ <literal>Session</literal>ì„ í•ìƒ 얻게 ë 것ì´ë‹¤. ì´ê²ƒì€ resource-local 환경 ë˜ëŠ” JTA í™˜ê²½ì— ëŒ€í•´ 구성ë˜ì–´ì•¼ 하며, <xref linkend=\"architecture-current-session\"/>ì„ ë³´ë¼."
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "때때로 \"ë·°ê°€ ë Œë”ë§ë 때까지\" í•˜ë‚˜ì˜ <literal>Session</literal> ê³¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì˜ ì˜ì—ì„ í™•ìž¥ì‹œí‚¤ëŠ” ê²ƒì´ íŽ¸ë¦¬í•˜ë‹¤. ì´ê²ƒì€ ìš”ì²ì´ ì²˜ë¦¬ëœ í›„ì— í•˜ë‚˜ì˜ ë³„ë„ì˜ ë Œë”ë§ ë‹¨ê³„ë¥¼ 활용하는 서블릿 어플리케ì´ì…˜ë“¤ì—ì„œ 특히 ìœ ìš©í•˜ë‹¤. ë·° ë Œë”ë§ì´ 완료ë 때까지 ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 확장하는 ê²ƒì€ ë‹¹ì‹ ì´ ë‹¹ì‹ ìžì‹ ì˜ ì¸í„°ì…‰í„°ë¥¼ 구현하는 ê²½ìš°ì— í–‰í•˜ê¸°ê°€ 쉽다. 하지만 ë§Œì¼ ë‹¹ì‹ ì´ ì»¨í…Œì´ë„ˆì— ì˜í•´ 관리ë˜ëŠ” 트랜ìžì…˜ë“¤ì„ 가진 EJBë“¤ì— ì˜ì¡´í• 경우ì—, í•˜ë‚˜ì˜ EJB 메소드가 반환ë ë•Œ ìž„ì˜ì˜ ë·° ë Œë”ë§ì´ 시작ë 수 있기 ì „ì— í•˜ë‚˜ì˜ íŠ¸ëžœìžì…˜ì´ 완료ë˜ê¸° 때문ì—, 행하는 ê²ƒì´ ì‰½ì§€ 않다. ì´ <emphasis>Open Session in View</emphasis> íŒ¨í„´ì„ ë‘˜ëŸ¬ì‹¼ íŒë“¤ê³¼ ì˜ˆì œë“¤ì€ Hibernate 웹 사ì´íŠ¸ì™€ í¬ëŸ¼ì„ ë³´ë¼."
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr "ìž¥ê¸°ê°„ì˜ ëŒ€í™”"
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "session-per-request íŒ¨í„´ì€ ë‹¹ì‹ ì´ ìž‘ì—… ë‹¨ìœ„ë“¤ì„ ì„¤ê³„í•˜ëŠ”ë° ì‚¬ìš©í• ìˆ˜ 있는 ìœ ì¼í•œ ìœ ìš©í•œ ê°œë…ì´ ì•„ë‹ˆë‹¤. ë§Žì€ ë¹„ì§€ë‹ˆìŠ¤ í”„ë¡œì„¸ìŠ¤ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ ì ‘ê·¼ë“¤ì„ ì¤‘ìž¬í•˜ëŠ” ì‚¬ìš©ìž ì‚¬ì´ì˜ ì „ì²´ ì¼ë ¨ì˜ ìƒí˜¸ìž‘ìš©ë“¤ì„ í•„ìš”ë¡œ 한다. 웹과 엔터프ë¼ì´ì¦ˆ 어플리케ì´ì…˜ì—ì„œ ì‚¬ìš©ìž ìƒí˜¸ìž‘ìš©ì— ê±¸ì¹˜ëŠ” ê²ƒì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì— 허용ë˜ì§€ 않는다. ë‹¤ìŒ ì˜ˆì œë¥¼ ê²€í† í•˜ìž:"
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "대화ìƒìžì˜ 첫 번째 í™”ë©´ì´ ì—´ë¦¬ê³ , 사용ìžì—게 보여진 ë°ì´í„°ëŠ” íŠ¹ì • <literal>Session</literal>ê³¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ ì†ì— 로드ë˜ì—ˆë‹¤. 사용ìžê°€ ê°ì²´ë“¤ì„ 변경시키는 ê²ƒì´ ìžìœ ë¡ë‹¤."
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr "사용ìžëŠ” 5분 í›„ì— \"ì €ìž¥\"ì„ í´ë¦í•˜ê³ ê·¸ì˜ ë³€ê²½ë“¤ì´ ì˜ì†í™” ë˜ê¸°ë¥¼ 기대한다; 그는 ë˜í•œ 그가 ì´ ì •ë³´ë¥¼ 편집하는 ìœ ì¼í•œ ê°œì¸ì´ê³ 변경 충ëŒì´ ë°œìƒí•˜ì§€ 않기를 기대한다."
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr "우리는 사용ìžì˜ ê´€ì ì—ì„œ, ì´ê²ƒì„ ìž‘ì—… 단위, 장기간 실행ë˜ëŠ” <emphasis>대화</emphasis> (ë˜ëŠ” <emphasis>어플리케ì´ì…˜ 트랜ìžì…˜</emphasis>)ì´ë¼ê³ 명명한다. ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—ì„œ ì´ê²ƒì„ 어떻게 êµ¬í˜„í• ìˆ˜ 있는 ë§Žì€ ë°©ë²•ë“¤ì´ ì¡´ìž¬í•œë‹¤."
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "첫 번째 naive êµ¬í˜„ì€ ë™ì‹œì„± ë³€ê²½ì„ ë°©ì§€í•˜ê³ , 격리와 atomicity(ì›ìž 단위성)ì„ ë³´ìž¥í•˜ê¸° 위해 ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ ì†Œìœ ëœ ìž ê¸ˆìœ¼ë¡œ 사용ìžê°€ ìƒê°í•˜ëŠ”ë™ì•ˆ <literal>Session</literal>ê³¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ ìœ ì§€í• ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ ë¬¼ë¡ anti-패턴ì´ë‹¤. 왜ëƒí•˜ë©´ ìž ê¸ˆ ë‹¤íˆ¼ì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ë™ì‹œ 사용ìžë“¤ì˜ 가용 숫ìžë¥¼ 높ì´ëŠ” ê²ƒì„ í—ˆìš©í•˜ì§€ ì•Šì„ ê²ƒì´ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr "명료하게, 우리는 대화(<emphasis>어플리케ì´ì…˜ 트랜ìžì…˜</emphasis>)를 êµ¬í˜„í•˜ëŠ”ë° ëª‡ëª‡ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì„ 사용해야 한다. ì´ ê²½ìš°ì—, 비지니스 í”„ë¡œì„¸ìŠ¤ë“¤ì˜ ê²©ë¦¬ë¥¼ ìœ ì§€í•˜ëŠ” ê²ƒì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ í‹°ì–´ì˜ ë¶€ë¶„ì ì¸ ì±…ìž„ì´ ëœë‹¤. ë‹¨ì¼ ëŒ€í™”ëŠ” 대개 여러 ê°œì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì— 걸친다. ê·¸ê²ƒì€ ì´ë“¤ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ 중 ì˜¤ì§ í•œ ê°œ(마지막 트랜ìžì…˜)ê°€ ì—…ë°ì´íŠ¸ëœ ë°ì´í„°ë¥¼ ì €ìž¥í•˜ê³ , ëª¨ë“ ë‹¤ë¥¸ 트랜ìžì…˜ë“¤ì´ 단순히 ë°ì´í„°ë¥¼ ì½ëŠ” (예를 들면, 몇몇 ìš”ì²/ì‘답 ì£¼ê¸°ì— ê±¸ì¹˜ëŠ” 마법사 스타ì¼ì˜ 대화 ìƒìžì—ì„œ) 경우ì—만 ì›ìžë‹¨ìœ„ê°€ ë 것ì´ë‹¤. 특히 ë‹¹ì‹ ì´ Hibernateì˜ íŠ¹ì§•ë“¤ì„ ì‚¬ìš©í• ê²½ìš°ì— , ì´ê²ƒì€ 들리는 것보다 구현하기가 ë” ì‰½ë‹¤:"
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr "<emphasis>ìžë™ì ì¸ ë²„ì „í™”</emphasis> - Hibernate는 ë‹¹ì‹ ì„ ìœ„í•´ ìžë™ì ì¸ optimistic ë™ì‹œì„± ì œì–´ë¥¼ í–‰í• ìˆ˜ ìžˆê³ , ê·¸ê²ƒì€ ì‚¬ìš©ìžê°€ ìƒê°í•˜ëŠ” 시간 ë™ì•ˆ ë™ì‹œì ì¸ ë³€ê²½ì´ ë°œìƒí–ˆëŠ”지를 ìžë™ì 으로 ê²€ì¶œí• ìˆ˜ 있다. 대개 우리는 ì˜¤ì§ ëŒ€í™”ì˜ ëì—ì„œ ì²´í¬í•œë‹¤."
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "<emphasis>Detached ê°ì²´ë“¤</emphasis> - ë§Œì¼ ë‹¹ì‹ ì´ ì´ë¯¸ ë…¼ì˜ëœ <emphasis>session-per-request</emphasis> íŒ¨í„´ì„ ì‚¬ìš©í•˜ê³ ìž ê²°ì •í•˜ëŠ” 경우, ëª¨ë“ ë¡œë“œëœ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ 사용ìžê°€ ìƒê°í•˜ëŠ” 시간 ë™ì•ˆ detached ìƒíƒœì— ìžˆì„ ê²ƒì´ë‹¤. Hibernate는 ê·¸ ê°ì²´ë“¤ì„ ìž¬ì²¨ë¶€ì‹œí‚¤ê³ ë³€ê²½ë“¤ì„ ì˜ì†í™” 시키는 ê²ƒì„ í—ˆìš©í•´ì£¼ë©°, ê·¸ íŒ¨í„´ì€ <emphasis>session-per-request-with-detached-objects(detached-ê°ì²´ë“¤ì„ 가진 ìš”ì² ë‹¹ 세션)</emphasis>으로 명명ëœë‹¤. ìžë™ì ì¸ ë²„ì „í™”ëŠ” ë™ì‹œì„± ë³€ê²½ë“¤ì„ ê²©ë¦¬ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ëœë‹¤."
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr "<emphasis>í™•ìž¥ëœ (ë˜ëŠ” Long) Session</emphasis> - Hibernate <emphasis>Session</emphasis>ì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì´ ì»¤ë°‹ëœ í›„ì— ê¸°ë³¸ JDBC ì»¤ë„¥ì…˜ì´ ì—°ê²° í•´ì œë ìˆ˜ë„ ìžˆê³ , 새로운 í´ë¼ì´ì–¸íŠ¸ ìš”ì²ì´ ë°œìƒí• ë•Œ 다시 ì—°ê²°ë 수 있다. ì´ íŒ¨í„´ì€ <emphasis>session-per-conversation(대화 당 세션)</emphasis>으로 ì•Œë ¤ì ¸ ìžˆê³ ìž¬ì²¨ë¶€ë¥¼ 불필요하게 ë§Œë“ ë‹¤. ìžë™ì ì¸ ë²„ì „í™”ëŠ” ë™ì‹œì„± ë³€ê²½ë“¤ì„ ê²©ë¦¬ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë˜ê³ <literal>Session</literal>ì€ ìžë™ì 으로 flushë˜ëŠ” ê²ƒì´ í—ˆìš©ë˜ì§€ 않지만 명시ì 으로 flushë˜ëŠ” ê²ƒì€ í—ˆìš©ëœë‹¤."
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr "<emphasis>session-per-request-with-detached-objects</emphasis>ê³¼ <emphasis>session-per-conversation</emphasis> ì–‘ìžëŠ” 장ì 들과 단ì ë“¤ì„ ê°–ëŠ”ë°, 우리는 ì´ ìž¥ì˜ ë’· 부분ì—ì„œ optimistic ë™ì‹œì„± ì œì–´ 단ë½ì—ì„œ ê·¸ê²ƒë“¤ì„ ë…¼ì˜í•œë‹¤."
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr "ê°ì²´ identity ê³ ë ¤í•˜ê¸°"
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr "어플리케ì´ì…˜ì€ ë‘ ê°œì˜ ë‹¤ë¥¸ <literal>Session</literal>들 ë‚´ì— ìžˆëŠ” ë™ì¼í•œ ì˜ì† ìƒíƒœì— ë™ì‹œì— ì ‘ê·¼í• ìˆ˜ë„ ìžˆë‹¤. 하지만 ì˜ì† í´ëž˜ìŠ¤ì˜ ì¸ìŠ¤í„´ìŠ¤ëŠ” ë‘ ê°œì˜ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ 사ì´ì— ê²°ì½” ê³µìœ ë˜ì§€ 않는다. 그러므로 identityì— ëŒ€í•œ ë‘ ê°œì˜ ë‹¤ë¥¸ ê°œë…ë“¤ì´ ì¡´ìž¬í•œë‹¤:"
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ Identity"
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr "foo.getId().equals( bar.getId() )"
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr "JVM Identity"
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr "foo==bar"
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr "그때 (예를 들어 <literal>Session</literal> ì˜ì—ì—ì„œ) <emphasis>íŠ¹ì •</emphasis> <literal>Session</literal>ì— ì²¨ë¶€ëœ ê°ì²´ë“¤ì˜ 경우 ë‘ ê°œì˜ ê°œë…ë“¤ì€ ë™ë“±í•œ 것ì´ê³ , ë°ì´í„°ë² ì´ìŠ¤ identityì— ëŒ€í•œ JVM identityê°€ Hibernateì— ì˜í•´ 보장ëœë‹¤. 하지만, 어플리케ì´ì…˜ì´ ë‘ ê°œì˜ ë‹¤ë¥¸ 세션들ì—ì„œ \"ë™ì¼í•œ\" (ì˜ì† identity) 비지니스 ê°ì²´ì— ë™ì‹œì— ì ‘ê·¼í•˜ëŠ” ë™ì•ˆ, ë‘ ê°œì˜ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ì‹¤ì œë¡œ \"다르다\"(JVM identity). 충ëŒë“¤ì€ flush/커밋 ì‹œì— (ìžë™ì ì¸ ë²„ì „í™”)를 사용하여, optimistic ì ‘ê·¼ë²•ì„ ì‚¬ìš©í•˜ì—¬ í•´ê²°ëœë‹¤."
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr "ì´ ì ‘ê·¼ë²•ì€ Hibernate와 ë°ì´í„°ë² ì´ìŠ¤ê°€ ë™ì‹œì„±ì— 대해 ê±±ì •í•˜ì§€ ì•Šë„ë¡ í•´ì¤€ë‹¤; ê·¸ê²ƒì€ ë˜í•œ 최ìƒì˜ scalability를 ì œê³µí•œë‹¤. 왜ëƒí•˜ë©´ ë‹¨ì¼ ì“°ë ˆë“œ-ìž‘ì—… 단위 ë‚´ì—ì„œ identity ë³´ìž¥ì€ ë‹¨ì§€ ë¹„ìš©ì´ ë“œëŠ” ìž ê¸ˆì´ë‚˜ 다른 ë™ê¸°í™” ìˆ˜ë‹¨ë“¤ì„ í•„ìš”ë¡œ 하지 않기 때문ì´ë‹¤. 어플리케ì´ì…˜ì€ ê·¸ê²ƒì´ <literal>Session</literal> 당 ë‹¨ì¼ ì“°ë ˆë“œë¥¼ ê°•ì œí•˜ëŠ” í•œ, ì–´ë–¤ 비지니스 ê°ì²´ì— 대해 ê²°ì½” ë™ê¸°í™” 시킬 필요가 없다. í•˜ë‚˜ì˜ <literal>Session</literal> ë‚´ì—ì„œ 어플리케ì´ì…˜ì€ ê°ì²´ë“¤ì„ 비êµí•˜ëŠ”ë° <literal>==</literal>를 ì•ˆì „í•˜ê²Œ ì‚¬ìš©í• ìˆ˜ê°€ 있다."
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "하지만, í•˜ë‚˜ì˜ <literal>Session</literal> 외부ì—ì„œ <literal>==</literal>를 사용하는 어플리케ì´ì…˜ì€ 예기치 ì•Šì€ ê²°ê³¼ë“¤ì„ ë³´ê²Œ ë ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ ì–´ë–¤ 예기치 ì•Šì€ ìž¥ì†Œë“¤ì—ì„œ, 예를 들어 ë‹¹ì‹ ì´ ë‘ ê°œì˜ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ë™ì¼í•œ <literal>Set</literal> ë‚´ì— ì§‘ì–´ë„£ì„ ê²½ìš°ì— ë°œìƒí• ìˆ˜ë„ ìžˆë‹¤. 둘 다 ë™ì¼í•œ ë°ì´í„°ë² ì´ìŠ¤ identity를 가질 수 있지만 (예를 들어 ê·¸ê²ƒë“¤ì€ ë™ì¼í•œ í–‰ì„ í‘œí˜„í•œë‹¤), JVM identity는 ì •ì˜ ìƒ detached ìƒíƒœì— 있는 ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 보장하지 않는다. 개발ìžëŠ” ì˜ì† í´ëž˜ìŠ¤ë“¤ë‚´ì— <literal>equals()</literal> 메소드와 <literal>hashCode()</literal> 메소드를 오버ë¼ì´ë“œ 시켜야 í•˜ê³ ê°ì²´ equalityì— ëŒ€í•œ ê·¸ ìžì‹ ì˜ ê°œë…ì„ êµ¬í˜„í•´ì•¼ 한다. í•˜ë‚˜ì˜ ê²½ê³ ê°€ 존재한다: equality를 êµ¬í˜„í•˜ëŠ”ë° ë°ì´í„°ë² ì´ìŠ¤ identifier를 ê²°ì½” 사용하지 ë§ê³ , í•˜ë‚˜ì˜ ë¹„ì§€ë‹ˆìŠ¤ í‚!
¤, ìœ ì¼í•œ, 대개 ë¶ˆë³€ì¸ ì†ì„±ë“¤ì˜ ì¡°í•©ì„ ì‚¬ìš©í•˜ë¼. ë°ì´í„°ë² ì´ìŠ¤ ì‹ë³„ìžëŠ” ë§Œì¼ transient ê°ì²´ê°€ ì˜ì†í™”ë˜ëŠ” ê²½ìš°ì— ë³€ê²½ë 것ì´ë‹¤. ë§Œì¼ transient ì¸ìŠ¤í„´ìŠ¤ê°€(대개 detached ì¸ìŠ¤í„´ìŠ¤ë“¤ê³¼ 함께) <literal>Set</literal> ë‚´ì— ë³´ê´€ë˜ëŠ” 경우ì—, hashcode ë³€ê²½ì€ <literal>Set</literal>ì˜ ê³„ì•½ì„ íŒŒê¸°ì‹œí‚¨ë‹¤. 비지니스 í‚¤ë“¤ì— ëŒ€í•œ ì†ì„±ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ 프ë¼ì´ë¨¸ë¦¬ 키들 ë§Œí¼ ì•ˆì •ì ì´ì–´ì„œëŠ” 안ë˜ë©°, ë‹¹ì‹ ì€ ì˜¤ì§ ê°ì²´ë“¤ì´ ë™ì¼í•œ <literal>Set</literal> ë‚´ì— ìžˆëŠ” í•œì—ì„œ ì•ˆì •ì„±ì„ ë³´ìž¥í•´ì•¼ë§Œ 한다. ì´ ìŸì ì— ê´€í•œ ë…¼ì˜ì— 대한 ë” ë§Žì€ ê²ƒì„ Hibernate 웹 사ì´íŠ¸ë¥¼ ë³´ë¼. ë˜í•œ ì´ê²ƒì´ Hibernate ìŸì ì´ ì•„ë‹ˆë©°, 단지 ìžë°” ê°ì²´ identity와 equalityê°€ 구현ë˜ì–´ì•¼ 하는 ë°©ë²•ìž„ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr "ê³µí†µëœ ìŸì 들"
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr "안티-패턴들 <emphasis>session-per-user-session</emphasis> ë˜ëŠ” <emphasis>session-per-application</emphasis>ì„ ê²°ì½” 사용하지 ë§ë¼(ë¬¼ë¡ ì´ ê·œì¹™ì— ëŒ€í•œ 드문 예외ìƒí™©ë“¤ì´ 존재한다). ë‹¤ìŒ ìŸì 들 중 ëª‡ëª‡ì´ ë˜í•œ 권장ë˜ëŠ” 패턴들로 ë‚˜íƒ€ë‚ ìˆ˜ 있ìŒì„ ë…¸íŠ¸í•˜ê³ , ë‹¹ì‹ ì´ ì„¤ê³„ ê²°ì •ì„ ë‚´ë¦¬ê¸° ì „ì— ë‚´í¬ëœ ì˜ë¯¸ë“¤ì„ 확실히 ì´í•´í•˜ë¼:"
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "<literal>Session</literal>ì€ ì“°ë ˆë“œ-ì•ˆì „í•˜ì§€ 않다. HTTP ìš”ì²ë“¤, 세션 빈즈, ë˜ëŠ” Swing worker들처럼 ë™ì‹œì— 작업하는 것으로 ê°€ì •ë˜ëŠ” ê²ƒë“¤ì€ í•˜ë‚˜ì˜ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ê°€ ê³µìœ ë ê²½ìš°ì— ê²½ìŸ ì¡°ê±´ë“¤ì„ ë°œìƒì‹œí‚¬ 것ì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ <literal>HttpSession</literal> ë‚´ì— Hibernate <literal>Session</literal>ì„ ìœ ì§€ì‹œí‚¤ëŠ” 경우(ë‚˜ì¤‘ì— ë…¼ì˜ë¨), ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ Http ì„¸ì…˜ì— ëŒ€í•œ ì ‘ê·¼ì„ ë™ê¸°í™” 시키는 ê²ƒì„ ê³ ë ¤í•´ì•¼ 한다. ê·¸ ë°–ì˜ ê²½ìš°, 충분히 ë¹ ë¥´ê²Œ reload를 í´ë¦í•˜ëŠ” 사용ìžëŠ” ë‘ ê°œì˜ ë™ì‹œì 으로 실행ë˜ëŠ” ì“°ë ˆë“œë“¤ ë‚´ì—ì„œ ë™ì¼í•œ <literal>Session</literal>ì„ ì‚¬ìš©í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr "Hibernateì— ì˜í•´ ë˜ì ¸ì§„ 예외ìƒí™©ì€ ë‹¹ì‹ ì´ ë‹¹ì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 롤백 ì‹œí‚¤ê³ ì¦‰ì‹œ <literal>Session</literal>ì„ ë‹«ì•„ì•¼ í•¨ì„ ì˜ë¯¸í•œë‹¤(ë‚˜ì¤‘ì— ìƒì„¸ížˆ ë…¼ì˜ë¨). ë§Œì¼ ë‹¹ì‹ ì˜ <literal>Session</literal>ì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— ë°”ì¸ë“œ ë˜ì–´ 있는 경우, ë‹¹ì‹ ì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ 중지시켜야 한다. ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ ë¡¤ë°±ì€ ë‹¹ì‹ ì˜ ë¹„ì§€ë‹ˆìŠ¤ ê°ì²´ë“¤ì„ ê·¸ê²ƒë“¤ì´ íŠ¸ëžœìžì…˜ì˜ 시작 ì‹œì— ë¨¸ë¬¼ë €ë˜ ìƒíƒœë¡œ ë˜ëŒë¦¬ì§€ëŠ” 않는다. ì´ê²ƒì€ ë°ì´í„°ë² ì´ìŠ¤ ìƒíƒœì™€ 비지니스 ê°ì²´ë“¤ì´ ë™ê¸°í™”를 ë²—ì–´ë‚¨ì„ ì˜ë¯¸í•œë‹¤. 대개 ì´ê²ƒì€ ë¬¸ì œê°€ 아니다. 왜ëƒí•˜ë©´ 예외ìƒí™©ë“¤ì€ 회복가능한 ê²ƒì´ ì•„ë‹ˆê³ ë‹¹ì‹ ì´ ì–´ë–»ê²Œë“ ë¡¤ë°± í›„ì— ì‹œìž‘í•´ì•¼ 하기 때문ì´ë‹¤."
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr "<literal>Session</literal>ì€ (Hibernateì— ì˜í•´ dirty ìƒíƒœë¡œ 관찰ë˜ì—ˆê±°ë‚˜ ì²´í¬ëœ) ì˜ì† ìƒíƒœì— 있는 ëª¨ë“ ê°ì²´ë¥¼ ìºì‹œ 시킨다. ì´ê²ƒì€ ë‹¹ì‹ ì´ ì˜¤ëžœ 시간 ë™ì•ˆ <literal>Session</literal>ì„ ì—´ì–´ë‘” 채로 ìœ ì§€í•˜ê±°ë‚˜ 단순하게 너무 ë§Žì€ ë°ì´í„°ë¥¼ 로드시킬 경우ì—, ë‹¹ì‹ ì´ OutOfMemoryExceptionì„ ì–»ê¸° ì „ê¹Œì§€, ê·¸ê²ƒì´ ëì—†ì´ ì„±ìž¥í•œë‹¤ëŠ” ì ì„ ì˜ë¯¸í•œë‹¤. ì´ê²ƒì— 대한 í•˜ë‚˜ì˜ í•´ê²°ì±…ì€ <literal>Session</literal> ìºì‹œë¥¼ 관리하기 위해 <literal>clear()</literal>와 <literal>evict()</literal>를 호출하는 것ì´ì§€ë§Œ, ë‹¹ì‹ ì´ ëŒ€ìš©ëŸ‰ ë°ì´í„° 오í¼ë ˆì´ì…˜ë“¤ì„ 필요로 하는 ê²½ìš°ì— ë‹¹ì‹ ì€ ëŒ€ê°œ 내장 í”„ë¡œì‹œì €ë¥¼ ê³ ë ¤í•´ì•¼ í• ê²ƒì´ë‹¤. 몇몇 í•´ê²°ì±…ë“¤ì´ <xref linkend=\"batch\"/>ì— ë³´ì—¬ì ¸ 있다. ì‚¬ìš©ìž ì„¸ì…˜ ë™ì•ˆì— <literal>Session</literal>ì„ ì—´ë ¤ì§„ 채로 ìœ ì§€í•˜ëŠ” ê²ƒì€ ë˜í•œ ì‹¤íš¨ì„±ì´ ë–¨ì–´ì§„ ë°ì´í„°ì— 대한 ë†!
’ì€ í™•ë¥ ì„ ì˜ë¯¸í•œë‹¤."
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ 경계 ì„¤ì •"
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ (ë˜ëŠ” 시스템) 트랜ìžì…˜ ê²½ê³„ë“¤ì€ í•ìƒ 필수ì ì´ë‹¤. ë°ì´í„°ë² ì´ìŠ¤ì™€ì˜ í†µì‹ ì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì˜ 외부ì—ì„œ ë°œìƒí• 수 없다(ì´ê²ƒì€ ìžë™-커밋 모드로 사용ë˜ëŠ” ë§Žì€ ê°œë°œìžë“¤ì—게는 혼ë™ìŠ¤ëŸ¬ì›Œ ë³´ì¸ë‹¤). í•ìƒ 심지어 ì½ê¸° ì „ìš© 오í¼ë ˆì´ì…˜ë“¤ì— ëŒ€í•´ì„œë„ ëª…ë£Œí•œ 트랜ìžì…˜ ê²½ê³„ë“¤ì„ ì‚¬ìš©í•˜ë¼. ë‹¹ì‹ ì˜ ê²©ë¦¬ ë ˆë²¨ê³¼ ë°ì´í„°ë² ì´ìŠ¤ ê°€ìš©ì„±ë“¤ì— ë”°ë¼, ì´ê²ƒì€ 필요하지 ì•Šì„ ìˆ˜ 있지만, ë§Œì¼ ë‹¹ì‹ ì´ í•ìƒ 트랜ìžì…˜ë“¤ì„ 명시ì 으로 경계 ì„¤ì •í• ê²½ìš°ì—는 하강하는 ê²°ì ë“¤ì´ ì¡´ìž¬í•˜ì§€ 않는다. 확실히, í•˜ë‚˜ì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì€ 심지어 ë°ì´í„° ì½ê¸°ì¡°ì°¨ë„ ë§Žì€ ìž‘ì€ íŠ¸ëžœìžì…˜ë“¤ì˜ 경우보다는 ë” ì¢‹ê²Œ 수행ë 것ì´ë‹¤."
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr "Hibernate 어플리케ì´ì…˜ì€ 관리ë˜ì§€ 않는 환경(예를 들면. ìŠ¤íƒ ë“œì–¼ë¡ , 간단히 웹 어플리케ì´ì…˜ë“¤ ë˜ëŠ” Swing 어플리케ì´ì…˜ë“¤)ê³¼ 관리ë˜ëŠ” J2EE 환경ì—ì„œ 실행ë 수 있다. 관리ë˜ì§€ 않는 환경ì—ì„œ, Hibernate는 대개 그것 ìžì‹ ì˜ ë°ì´í„°ë² ì´ìŠ¤ 커넥션 í’€ì— ëŒ€í•œ ì±…ìž„ì´ ìžˆë‹¤. 어플리케ì´ì…˜ 개발ìžëŠ” 트랜ìžì…˜ ê²½ê³„ë“¤ì„ ì†ìˆ˜ ì„¤ì •í•´ì•¼ 한다. 달리 ë§í•´, ê°œë°œìž ìŠ¤ìŠ¤ë¡œ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì„ ì‹œìž‘í•˜ê³ , 커밋시키거나 롤백시켜야 한다. 관리ë˜ëŠ” í™˜ê²½ì€ ëŒ€ê°œ 예를 들어 EJB 세션 ë¹ˆì¦ˆì˜ ë°°ì¹˜ 디스í¬ë¦½í„° ì†ì— ì„ ì–¸ì 으로 ì •ì˜ëœ 트랜ìžì…˜ 어셈블리를 가진, 컨테ì´ë„ˆì— ì˜í•´-관리ë˜ëŠ” 트랜ìžì…˜ë“¤(CMT)ì„ ì œê³µí•œë‹¤. 그때 프로그램 ìƒì˜ 트랜ìžì…˜ 경계 ì„¤ì •ì€ ë” ì´ìƒ 필요하지 않다."
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "하지만, CMT ëŒ€ì‹ BMT를 사용하는 JTAì— ì˜ì¡´í• 수 있는 시스템들, ê·¸ë¦¬ê³ ê´€ë¦¬ë˜ì§€ 않는 resource-local 환경들 사ì´ì—ì„œ ë‹¹ì‹ ì˜ ì˜ì† ê³„ì¸µì— ì´ì‹ì„±ì„ ìœ ì§€ì‹œí‚¤ëŠ” ê²ƒì´ ìžì£¼ í¬ë§ëœë‹¤. ë‘ ê²½ìš°ë“¤ì—ì„œ ë‹¹ì‹ ì€ í”„ë¡œê·¸ëž¨ ìƒì˜ 트랜ìžì…˜ ê²½ê³„ì„¤ì •ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. Hibernate는 ë‹¹ì‹ ì˜ ë°°ì¹˜ í™˜ê²½ì˜ ê³ ìœ í•œ 트랜ìžì…˜ 시스템 ì†ìœ¼ë¡œ 변환ë˜ëŠ” <literal>Transaction</literal>ì´ë¼ 명명ë˜ëŠ” wrapper API 를 ì œê³µí•œë‹¤. ì´ API는 ì‹¤ì œë¡œ 옵션ì´ì§€ë§Œ 우리는 ë‹¹ì‹ ì´ CMT session bean ì†ì— 있지 않는 í•œ ê·¸ê²ƒì˜ ì‚¬ìš©ì„ ê°•ë ¥í•˜ê²Œ 권장한다."
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr "대개 <literal>Session</literal> 종료는 네 ê°œì˜ êµ¬ë¶„ë˜ëŠ” ë‹¨ê³„ë“¤ì„ ìˆ˜ë°˜í•œë‹¤:"
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr "ì„¸ì…˜ì„ flush 시킨다"
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr "트랜ìžì…˜ì„ 커밋 시킨다"
+
+#: index.docbook:395
+msgid "close the session"
+msgstr "ì„¸ì…˜ì„ ë‹«ëŠ”ë‹¤"
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr "예외ìƒí™©ë“¤ì„ 처리한다"
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr "ì„¸ì…˜ì„ flush 시키는 ê²ƒì€ ì•žì„œ ë…¼ì˜ë˜ì—ˆê³ , 우리는 ì´ì œ 관리ë˜ëŠ” 환경과 관리ë˜ì§€ 않는 환경 ì–‘ìžì—ì„œ 트랜ìžì…˜ 경계 ì„¤ì •ê³¼ 예외ìƒí™©ì„ ë” ìžì„¸ížˆ 살펴볼 것ì´ë‹¤."
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr "관리ë˜ì§€ 않는 환경"
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "ë§Œì¼ Hibernate ì˜ì† ê³„ì¸µì´ ê´€ë¦¬ë˜ì§€ 않는(non-managed) 환경ì—ì„œ 실행ë 경우, ë°ì´í„°ë² ì´ìŠ¤ ì»¤ë„¥ì…˜ë“¤ì€ ëŒ€ê°œ Hibernateê°€ í•„ìš”ë¡œí• ë•Œ ì»¤ë„¥ì…˜ë“¤ì„ íšë“하는 간단한 (예를 들면 DataSourceê°€ ì•„ë‹Œ) 커넥션 í’€(pool)들로부터 처리ëœë‹¤. session/transaction 처리 관용구는 다ìŒê³¼ 같다:"
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr "ë‹¹ì‹ ì€ <literal>Session</literal>ì„ ëª…ì‹œì 으로 <literal>flush()</literal> 하지 ë§ì•„야 한다 - <literal>commit()</literal>ì— ëŒ€í•œ í˜¸ì¶œì€ (ê·¸ ì„¸ì…˜ì— ëŒ€í•œ <xref linkend=\"objectstate-flushing\"/>FlushModeì— ë”°ë¼)ìžë™ì 으로 ë™ê¸°í™”를 트리거시킨다. <literal>close()</literal>ì— ëŒ€í•œ í˜¸ì¶œì€ ì„¸ì…˜ì˜ ëì„ ë§ˆí¬í•œë‹¤. <literal>close()</literal>ì˜ ì£¼ëœ êµ¬í˜„ì€ JDBC ì»¤ë„¥ì…˜ì´ ê·¸ ì„¸ì…˜ì— ì˜í•´ í¬ê¸°ë 것ì´ë¼ëŠ” ì ì´ë‹¤. ì´ Java 코드는 관리ë˜ì§€ 않는 환경과 JTA 환경 ì–‘ìžì—ì„œ ì´ì‹ì„±ì´ ìžˆê³ ì‹¤í–‰ëœë‹¤."
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr "보다 ë” ìœ ì—°í•œ í•´ê²°ì±…ì€ ì•žì„œ ì„¤ëª…í–ˆë“¯ì´ Hibernateì˜ ë¯¸ë¦¬ 빌드ë˜ì–´ 있는 \"현재 세션\" 컨í…스트 관리ì´ë‹¤:"
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr "ë‹¹ì‹ ì€ í†µìƒì˜ 어플리케ì´ì…˜ì—ì„œ 비지니스 코드 ì†ì— ì´ ê´€ìš©êµ¬ë¥¼ ê²°ì½” 보지 ì•Šì„ ê²ƒì´ë‹¤; 치명ì ì¸(시스템) 예외ìƒí™©ë“¤ì€ í•ìƒ \"ìƒë‹¨\"ì—ì„œ 잡혀야 한다. 달리 ë§í•´, (ì˜ì† 계층ì—ì„œ) Hibernate í˜¸ì¶œë“¤ì„ ì‹¤í–‰ì‹œí‚¤ëŠ” 코드와 <literal>RuntimeException</literal>ì„ ì²˜ë¦¬í•˜(ê³ ëŒ€ê°œ ì˜¤ì§ ì œê±°í•˜ê³ ë¹ ì ¸ë‚˜ê°ˆ 수 있는) 코드는 다른 계층들 ì†ì— 있다. Hibernateì— ì˜í•œ 현재 컨í…스트 관리는 ì´ ì„¤ê³„ë¥¼ 현격하게 단순화시켜서, ë‹¹ì‹ ì´ í•„ìš”ë¡œ 하는 ëª¨ë“ ê²ƒì€ <literal>SessionFactory</literal>ì— ëŒ€í•œ ì ‘ê·¼ì´ë‹¤.예외ìƒí™© 처리는 ì´ ìž¥ì˜ ë’·ë¶€ë¶„ì—ì„œ ë…¼ì˜ëœë‹¤."
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "ë‹¹ì‹ ì€ (ë””í´íŠ¸ì¸) <literal>org.hibernate.transaction.JDBCTransactionFactory</literal>를 ì„ íƒí•´ì•¼ í•˜ê³ , ë‘번째 ì˜ˆì œì˜ ê²½ìš° ë‹¹ì‹ ì˜ <literal>hibernate.current_session_context_class</literal>를 ì„ íƒí•´ì•¼ í•¨ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr "JTA 사용하기"
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì˜ ì˜ì† ê³„ì¸µì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ 서버ì—ì„œ(예를 들어, EJB 세션 빈즈 ì´ë©´ì—ì„œ) 실행ë 경우, Hibernateì— ì˜í•´ íšë“ëœ ëª¨ë“ ë°ì´í„°ì†ŒìŠ¤ ì»¤ë„¥ì…˜ì€ ìžë™ì 으로 ì „ì— JTA 트랜ìžì…˜ì˜ ë¶€ë¶„ì¼ ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ ë˜í•œ ìŠ¤íƒ ë“œì–¼ë¡ JTA êµ¬í˜„ì„ ì„¤ì¹˜í• ìˆ˜ ìžˆê³ EJB ì—†ì´ ê·¸ê²ƒì„ ì‚¬ìš©í• ìˆ˜ 있다. Hibernate는 JTA í†µí•©ì„ ìœ„í•œ ë‘ ê°œì˜ ë°©ë„ë“¤ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ bean-managed transactions(BMT)를 ì‚¬ìš©í• ê²½ìš° Hibernate는 ë‹¹ì‹ ì´ <literal>Transaction</literal> API를 ì‚¬ìš©í• ê²½ìš°ì— BMT 트랜ìžì…˜ì„ ì‹œìž‘í•˜ê³ ì¢…ë£Œí•˜ë„ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ 서버ì—게 ì•Œë ¤ì¤„ 것ì´ë‹¤. ë”°ë¼ì„œ 트랜ìžì…˜ 관리 코드는 non-managed 환경과 ë™ì¼í•˜ë‹¤."
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ íŠ¸ëžœìžì…˜ì— ë¬¶ì¸ <literal>Session</literal>, 즉 쉬운 컨í…스트 ë³´ê¸‰ì„ ìœ„í•œ <literal>getCurrentSession()</literal> ê¸°ëŠ¥ì„ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우, ë‹¹ì‹ ì€ JTA <literal>UserTransaction</literal> API를 ì§ì ‘ 사용해야 í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr "CMTì˜ ê²½ìš°, 트랜ìžì…˜ ê´€í• [경계 ì„¤ì •]ì€ í”„ë¡œê·¸ëž¨ ìƒì´ ì•„ë‹Œ, session bean 배치 디스í¬ë¦½í„°ë“¤ ì†ì—ì„œ 행해진다. 그러므로 코드는 다ìŒìœ¼ë¡œ ê°ì†Œëœë‹¤:"
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr "왜ëƒí•˜ë©´ í•˜ë‚˜ì˜ ì„¸ì…˜ 빈 ë©”ì†Œë“œì— ì˜í•´ ë˜ì ¸ì§„ 처리ë˜ì§€ ì•Šì€ <literal>RuntimeException</literal>ì´ ê¸€ë¡œë²Œ 트랜ìžì…˜ì„ rollback으로 ì„¤ì •í•˜ë„ë¡ ì»¨í…Œì´ë„ˆì—게 ì•Œë ¤ì£¼ê¸° 때문ì—, CMT/EJBì—서조차 ë¡¤ë°±ì€ ìžë™ì 으로 ë°œìƒëœë‹¤. <emphasis>ì´ê²ƒì€ ë‹¹ì‹ ì´ BMT ì´ë“ CMTì´ë“ 모ë‘ì—ì„œ Hibernate <literal>Transaction</literal> API를 ì‚¬ìš©í• í•„ìš”ê°€ 없으며, ë‹¹ì‹ ì€ ê·¸ 트랜ìžì…˜ì— ë¬¶ì¸ \"현재\" Sessionì˜ ìžë™ì ì¸ ë³´ê¸‰(propagation)ì„ ì–»ê²Œ ë¨ì„ ì˜ë¯¸í•œë‹¤.</emphasis>"
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr "ë‹¹ì‹ ì´ Hibernateì˜ íŠ¸ëžœìžì…˜ íŒ©í† ë¦¬ë¥¼ êµ¬ì„±í• ë•Œ, ë‹¹ì‹ ì´ JTA를 ì§ì ‘ ì‚¬ìš©í• ê²½ìš°(BMT) ë‹¹ì‹ ì€ <literal>org.hibernate.transaction.JTATransactionFactory</literal>를 ì„ íƒí•´ì•¼í•˜ê³ , CMT session beanì—서는 <literal>org.hibernate.transaction.CMTTransactionFactory</literal>를 ì„ íƒí•´ì•¼ í•¨ì„ ë…¸íŠ¸í•˜ë¼. ë˜í•œ <literal>org.hibernate.transaction.manager_lookup_class</literal>를 ì„¤ì •í•˜ëŠ” ê²ƒì„ ì—¼ë‘ì— ë‘ë¼. 게다가 반드시 ë‹¹ì‹ ì˜ <literal>hibernate.current_session_context_class</literal>ì´ ì„¤ì •ë˜ì§€ ì•Šë„ë¡ í•˜ê±°ë‚˜(ì—호환성), ë˜ëŠ” <literal>\"jta\"</literal>ë¡œ ì„¤ì •ë˜ë„ë¡ í•˜ë¼."
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr "<literal>getCurrentSession()</literal> 오í¼ë ˆì´ì…˜ë“¤ì€ JTA 환경ì—ì„œ í•œ 가지 단ì ì„ ê°–ê³ ìžˆë‹¤. ë””í´íŠ¸ë¡œ 사용ë˜ëŠ”, <literal>after_statement</literal> 커넥션 í•´ì œ 모드 ì‚¬ìš©ì— ëŒ€í•œ í•˜ë‚˜ì˜ ë³´ë¥˜ 통보가 존재한다. JTA ëª…ì„¸ì„œì˜ ì–´ë¦¬ì„ì€ ì œí•œìœ¼ë¡œ ì¸í•´, Hibernateê°€ <literal>scroll()</literal> ë˜ëŠ” <literal>iterate()</literal>ì— ì˜í•´ 반환ë˜ëŠ” ìž„ì˜ì˜ 닫혀지지 ì•Šì€ <literal>ScrollableResults</literal> ë˜ëŠ” <literal>Iterator</literal> ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ ìžë™ì 으로 ì œê±°í•˜ëŠ” ê²ƒì´ ë¶ˆê°€ëŠ¥í•˜ë‹¤. ë‹¹ì‹ ì€ <literal>finally</literal> ë¸”ë¡ ë‚´ì—ì„œ 명시ì 으로 <literal>ScrollableResults.close()</literal> ë˜ëŠ” <literal>Hibernate.close(Iterator)</literal>를 호출하여 기본 ë°ì´í„°ë² ì´ìŠ¤ 커서를 í•´ì œ<emphasis>시켜야 한다</emphasis>.(ë¬¼ë¡ ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì€ JTA ë˜ëŠ” CMT 코드ì—ì„œ <literal>scroll()</literal>ì´ë‚˜ <literal>iterate()</litera!
l>를 사용하는 ê²ƒì„ ì‰½ê²Œ í”¼í• ìˆ˜ 있다.)"
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr "예외ìƒí™© 처리"
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "만ì¼<literal>Session</literal>ì´ (ì–´ë–¤ <literal>SQLException</literal>ì„ í¬í•¨í•˜ëŠ”) 예외ìƒí™©ì„ ë˜ì§ˆ 경우, ë‹¹ì‹ ì€ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 즉시 ë¡¤ë°±ì‹œí‚¤ê³ , <literal>Session.close()</literal>를 í˜¸ì¶œí•˜ê³ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ë¥¼ í기시켜야한다. <literal>Session</literal>ì˜ ì–´ë–¤ ë©”ì†Œë“œë“¤ì€ ê·¸ ì„¸ì…˜ì„ ì¼ê´€ëœ ìƒíƒœë¡œ 남겨ë‘지 <emphasis>ì•Šì„</emphasis> 것ì´ë‹¤. Hibernateì— ì˜í•´ ë˜ì ¸ì§„ 예외ìƒí™©ì€ 복구가능한 것으로 취급ë 수 없다. ê·¸ <literal>Session</literal>ì´ <literal>finally</literal> ë¸”ë¡ ë‚´ì—ì„œ <literal>close()</literal>를 호출하여 닫혀지ë„ë¡ í™•ì‹¤ížˆ 하ë¼."
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr "Hibernate ì˜ì† 계층ì—ì„œ ë°œìƒí• 수 있는 ëŒ€ë¶€ë¶„ì˜ ì˜¤ë¥˜ë“¤ì„ í¬ìž¥í•˜ëŠ”, <literal>HibernateException</literal>ì€ ì²´í¬ë˜ì§€ ì•Šì€ ì˜ˆì™¸ìƒí™©ì´ë‹¤(ê·¸ê²ƒì€ Hibernateì˜ ì´ì „ ë²„ì „ì—는 없었다). ìš°ë¦¬ì˜ ì˜ê²¬ìœ¼ë¡œ, 우리는 ë‚®ì€ ê³„ì¸µì—ì„œ 복구불가능한 예외ìƒí™©ì„ 붙잡ë„ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ 개발ìžì—게 ê°•ì œí•˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. ëŒ€ë¶€ë¶„ì˜ ì‹œìŠ¤í…œë“¤ì—ì„œ, ì²´í¬ë˜ì§€ ì•Šì€ ì¹˜ëª…ì ì¸ ì˜ˆì™¸ìƒí™©ë“¤ì€ (예를 들어, ë” ë†’ì€ ê³„ì¸µì—ì„œ) 메소드 호출 스íƒì˜ 첫 번째 í”„ë ˆìž„ë“¤ 중 하나 ì†ì—ì„œ 처리ë˜ê³ , í•œ ê°œì˜ ì˜¤ë¥˜ 메시지가 어플리케ì´ì…˜ 사용ìžì—게 표시ëœë‹¤(ë˜ëŠ” ì–´ë–¤ 다른 ì ì ˆí•œ ì•¡ì…˜ì´ ì·¨í•´ì§„ë‹¤). Hibernate는 ë˜í•œ <literal>HibernateException</literal>ì´ ì•„ë‹Œ, 다른 ì²´í¬ë˜ì§€ ì•Šì€ ì˜ˆì™¸ìƒí™©ë“¤ì„ ë˜ì§ˆ ìˆ˜ë„ ìžˆìŒì„ 노트하ë¼. 다시 ì´ê²ƒë“¤ì€ 복구가능하지 ì•Šê³ ì ì ˆí•œ ì•¡ì…˜ì´ ì·¨í•´ì ¸ì•¼ 한다."
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ì™€ ìƒí˜¸ìž‘용하는 ë™ì•ˆì— ë˜ì ¸ì§„ <literal>SQLException</literal>ë“¤ì„ í•˜ë‚˜ì˜ <literal>JDBCException</literal> ì†ì— í¬ìž¥í•œë‹¤. 사실, Hibernate는 ê·¸ 예외ìƒí™©ì„ <literal>JDBCException</literal>ì˜ ë³´ë‹¤ ì˜ë¯¸ìžˆëŠ” 서브í´ëž˜ìŠ¤ë¡œ ë³€í™˜í•˜ë ¤ê³ ì‹œë„í• ê²ƒì´ë‹¤. 기본 <literal>SQLException</literal>ì€ <literal>JDBCException.getCause()</literal>를 통해 í•ìƒ ì´ìš© 가능하다. Hibernate는<literal>SessionFactory</literal>ì— ì²¨ë¶€ëœ <literal>SQLExceptionConverter</literal>를 사용하여 <literal>SQLException</literal>ì„ ì 당한 í•˜ë‚˜ì˜ <literal>JDBCException</literal> 서브í´ëž˜ìŠ¤ë¡œ 변환시킨다. ë””í´íŠ¸ë¡œ <literal>SQLExceptionConverter</literal>는 êµ¬ì„±ëœ dialectì— ì˜í•´ ì •ì˜ëœë‹¤; 하지만 맞춤 구현 ì†ì— í”ŒëŸ¬ê·¸ì¸ ì‹œí‚¤ëŠ” ê²ƒì´ ë˜í•œ 가능하다(ìƒì„¸í•œ ê²ƒì€ <literal>SQLExceptionConverterFactory</literal> í´ëž˜ìŠ¤ì— 관한 javadocs를 ë³´ë¼). í!
‘œì¤€ <literal>JDBCException</literal> ì„œë¸Œíƒ€ìž…ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr "<literal>JDBCConnectionException</literal> - 기본 JDBC í†µì‹ ì— ëŒ€í•œ 오류를 나타낸다."
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr "<literal>SQLGrammarException</literal> - ìƒê²¨ë‚œ SQLì— ëŒ€í•œ 문법 ë˜ëŠ” 구문 ë¬¸ì œì ì„ ë‚˜íƒ€ë‚¸ë‹¤."
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr "<literal>ConstraintViolationException</literal> - 무결성 ì œì•½ ìœ„ë°˜ì— ê´€í•œ ì–´ë–¤ 형ì‹ì„ 나타낸다."
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "<literal>LockAcquisitionException</literal> - ìš”ì²ëœ 오í¼ë ˆì´ì…˜ì„ ì‹¤í–‰í•˜ëŠ”ë° í•„ìˆ˜ì ì¸ ìž ê¸ˆ ë ˆë²¨ì„ íšë“하는 오류를 나타낸다."
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr "<literal>GenericJDBCException</literal> - 다른 ì¹´í…Œê³ ë¦¬ë“¤ 중 ì–´ë–¤ 것으로 분류ë˜ì§€ ì•Šì•˜ë˜ ì¼ë°˜ì ì¸ ì˜ˆì™¸ìƒí™©."
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr "트랜ìžì…˜ 타임아웃"
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "관리ë˜ì§€ 않는 ì½”ë“œì— ëŒ€í•´ì„œëŠ” ê²°ì½” ì œê³µë˜ì§€ 않는 EJB와 ê°™ì´ ê´€ë¦¬ë˜ëŠ” í™˜ê²½ì— ì˜í•´ ì œê³µë˜ëŠ” í•œ 가지 극히 중요한 íŠ¹ì§•ì€ íŠ¸ëžœìžì…˜ 타임아웃ì´ë‹¤. 트랜ìžì…˜ íƒ€ìž„ì•„ì›ƒì€ ì‚¬ìš©ìžì—게 ì‘ë‹µì„ ë°˜í™˜í•˜ì§€ 않는 ë™ì•ˆì— 무례한 í–‰ë™ì„ 행하는 트랜ìžì…˜ì´ ìžì›ë“¤ì„ ë¬´í•œì • 묶어둘 수 ì—†ìŒì„ ë³´ì¦í•´ì¤€ë‹¤. 관리ë˜ëŠ” (JTA) 환경 외부ì—ì„œ, Hibernate는 ì´ ê¸°ëŠ¥ì„ ì˜¨ì „í•˜ê²Œ ì œê³µí• ìˆ˜ 없다. 하지만 Hibernate는 ë°ì´í„°ë² ì´ìŠ¤ ë ˆë²¨ ë°ë“œë½ë“¤ê³¼ 거대한 ê²°ê³¼ ì…‹ë“¤ì„ ê°€ì§„ 질ì˜ë“¤ì´ ì •ì˜ëœ íƒ€ìž„ì•„ì›ƒì— ì˜í•´ ì œì•½ë˜ëŠ” ê²ƒì„ ë³´ìž¥í•¨ìœ¼ë¡œì¨ ìµœì†Œí•œ ë°ì´í„° ì ‘ê·¼ 오í¼ë ˆì´ì…˜ë“¤ì„ ì œì–´í• ìˆ˜ 있다. 관리ë˜ëŠ” 환경ì—ì„œ, Hibernate는 트랜ìžì…˜ íƒ€ìž„ì•„ì›ƒì„ JTAì—게 위임시킬 수 있다. ì´ ê¸°ëŠ¥ì€ Hibernate <literal>Transaction</literal> ê°ì²´ì— ì˜í•´ 추ìƒí™” ëœë‹¤."
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr "<literal>setTimeout()</literal>ì€ CMT bean ë‚´ì—ì„œ 호출ë„리 수 ì—†ìŒì„ 노트하ë¼. 여기서 트랜ìžì…˜ íƒ€ìž„ì•„ì›ƒë“¤ì€ ì„ ì–¸ì 으로 ì •ì˜ë˜ì–´ì•¼ 한다."
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr "Optimistic ë™ì‹œì„± ì œì–´"
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "ê³ ë„ì˜ ë™ì‹œì„±ê³¼ ê³ ë„ì˜ ê°€ìš©ì„±ì„ ì¼ì¹˜ì‹œí‚¤ëŠ” ìœ ì¼í•œ ì ‘ê·¼ë²•ì€ ë²„ì „í™”ë¥¼ 가진 optimisticë™ì‹œì„± ì œì–´ì´ë‹¤. ë²„ì „ ì²´í‚¹ì€ ì—…ë°ì´íŠ¸ 충ëŒì„ 검출하기 위해(ê·¸ë¦¬ê³ ì—…ë°ì´íŠ¸ ì†ì‹¤ì„ 방지하기 위해) ë²„ì „ 번호들 ë˜ëŠ” timestampë“¤ì„ ì‚¬ìš©í•œë‹¤. Hibernate는 optimistic ë™ì‹œì„±ì„ 사용하는 어플리케ì´ì…˜ 코드 ìž‘ì„±ì— ì„¸ 가지 가능한 ì ‘ê·¼ë²•ë“¤ì„ ì œê³µí•œë‹¤. 우리가 보여주는 ì“°ìž„ìƒˆë“¤ì€ ìž¥ì‹œê°„ì˜ ëŒ€í™”ì˜ ìƒí™© ì†ì— 있지만, ë²„ì „ 체킹 ë˜í•œ ë‹¨ì¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ë“¤ì—ì„œ ì—…ë°ì´íŠ¸ ì†ì‹¤ì„ 방지하는 ì´ì ì„ ê°–ê³ ìžˆë‹¤."
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr "어플리케ì´ì…˜ ë²„ì „ 체킹"
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr "í•˜ë‚˜ì˜ êµ¬í˜„ì—ì„œ Hibernate로부터 ë§Žì€ ë„ì›€ì´ ì—†ì´, ë°ì´í„°ë² ì´ìŠ¤ì— 대한 ê°ê°ì˜ ìƒí˜¸ìž‘ìš©ì€ ìƒˆë¡œìš´ <literal>Session</literal> ë‚´ì—ì„œ ì¼ì–´ë‚˜ê³ , 개발ìžëŠ” ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 처리하기 ì „ì— ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ëª¨ë“ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 다시 로드시킬 ì±…ìž„ì´ ìžˆë‹¤. ì´ ì ‘ê·¼ë²•ì€ ëŒ€í™” 트랜ìžì…˜ì„ 확실히 격리시키기 위해 그것 ìžì‹ ì˜ ë²„ì „ ì²´í‚¹ì„ ìˆ˜í–‰í•˜ë„ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—게 ê°•ì œì‹œí‚¨ë‹¤."
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr "version 프로í¼í‹°ëŠ” <literal><version></literal>ì„ ì‚¬ìš©í•˜ì—¬ 매핑ë˜ê³ , Hibernate는 ë§Œì¼ ì—”í‹°í‹°ê°€ dirtyì¼ ê²½ìš° flush ë™ì•ˆì— ê·¸ê²ƒì„ ìžë™ì 으로 ì¦ê°€ì‹œí‚¬ 것ì´ë‹¤."
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "ë¬¼ë¡ , ë‹¹ì‹ ì´ ë‚®ì€ ë°ì´í„° ë™ì‹œì„± 환경ì—ì„œ ìž‘ì—…í•˜ê³ ìžˆê³ ë²„ì „ ì²´í‚¹ì„ í•„ìš”ë¡œ 하지 ì•Šì„ ê²½ìš°ì—, ë‹¹ì‹ ì€ ì´ ì ‘ê·¼ë²•ì„ ì‚¬ìš©í• ìˆ˜ ë„ ìžˆê³ ë‹¨ì§€ ë²„ì „ ì²´í¬ë¥¼ ìƒëžµí• ìˆ˜ë„ ìžˆë‹¤. ê·¸ 경우ì—, <emphasis>ë§ˆì§€ë§‰ì˜ ì»¤ë°‹ 성공</emphasis>ì€ ë‹¹ì‹ ì˜ ìž¥ì‹œê°„ì˜ ëŒ€í™”ì— ëŒ€í•œ ë””í´íŠ¸ ë°©ë„ê°€ ë 것ì´ë‹¤. ì´ê²ƒì´ 어플리케ì´ì…˜ì˜ 사용ìžë“¤ì„ 혼ë™ì‹œí‚¬ 수 있ìŒì„ ì—¼ë‘ì— ë‘ë¼. 왜ëƒí•˜ë©´ 사용ìžë“¤ì€ 오류 메시지들 ë˜ëŠ” ì¶©ëŒ ë³€ê²½ë“¤ì„ ë³‘í•©ì‹œí‚¬ 기회 ì—†ì´ ì—…ë°ì´íŠ¸ë“¤ ì†ì‹¤ì„ ê²ªì„ ìˆ˜ë„ ìžˆê¸° 때문ì´ë‹¤."
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "명료하게 수작업 ë²„ì „ ì²´í‚¹ì€ ë§¤ìš° 사소한 환경들ì—ì„œë„ ê³µí¬ì ì´ê³ ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì— 대해 ì‹¤ì œì ì´ì§€ 않다. í”히 ë‹¨ì¼ ì¸ìŠ¤í„´ìŠ¤ ë¿ë§Œ ì•„ë‹ˆë¼ ë³€ê²½ëœ ê°ì²´ë“¤ì˜ ì „ì²´ ê·¸ëž˜í”„ë“¤ì´ ì²´í¬ë˜ì–´ì•¼ 한다. Hibernate는 설계 패러다임으로서 í•˜ë‚˜ì˜ í™•ìž¥ëœ <literal>Session</literal> ë˜ëŠ” detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대해 ìžë™ì ì¸ ë²„ì „ ì²´í‚¹ì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr "í™•ìž¥ëœ ì„¸ì…˜ê³¼ ìžë™ì ì¸ ë²„ì „í™”"
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr "í•˜ë‚˜ì˜ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ì™€ ê·¸ê²ƒì˜ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ì „ì²´ 어플리케ì´ì…˜ 트랜ìžì…˜ì— 사용ëœë‹¤. Hibernate는 flush í• ë•Œ ì¸ìŠ¤í„´ìŠ¤ ë²„ì „ë“¤ì„ ì²´í¬í•˜ê³ ë§Œì¼ ë™ì‹œì„± ë³€ê²½ì´ ê²€ì¶œë ê²½ìš°ì— ì˜ˆì™¸ìƒí™©ì„ ë˜ì§„다. ì´ ì˜ˆì™¸ìƒí™©ì„ ìž¡ì•„ë‚´ê³ ì²˜ë¦¬í•˜ëŠ” ê²ƒì„ ê°œë°œìžì˜ 몫ì´ë‹¤(ê³µí†µëœ ì˜µì…˜ë“¤ì€ ë³€ê²½ë“¤ì„ ë³‘í•©ì‹œí‚¤ê±°ë‚˜ ë˜ëŠ” 쓸모가 없지 ì•Šì€ ë°ì´í„°ë¡œ 비지니스 프로세스를 다시 시작하는 기회를 사용ìžì—게 주는 것ì´ë‹¤). í•˜ë‚˜ì˜ <literal>Session</literal> ì¸ìŠ¤í„´ìŠ¤ì™€ ê·¸ê²ƒì˜ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ <emphasis>session-per-conversation</emphasis>ë¡œ ì•Œë ¤ì§„ ì „ì²´ ëŒ€í™”ì— ì‚¬ìš©ëœë‹¤. Hibernate는 flush ì‹œì ì—ì„œ ì¸ìŠ¤í„´ìŠ¤ ë²„ì „ë“¤ì„ ì²´í¬í•˜ë©°, ë§Œì¼ ë™ì‹œì ì¸ ë³€ê²½ì´ ê²€ì¶œë ê²½ìš°ì— í•˜ë‚˜ì˜ ì˜ˆì™¸ìƒí™©ì„ ë˜ì§„다. ì´ ì˜ˆì™¸ìƒí™©ì„ í¬ì°©í•˜ê³ 처리하는 ê²ƒì€ ê°œë°œìžì˜ 몫ì´ë‹¤(ê³µí†µëœ ì˜!
µì…˜ë“¤ì€ 사용ìžê°€ ë³€ê²½ë“¤ì„ ë³‘í•©í•˜ê±°ë‚˜ ì†ì‹¤ë˜ì§€ ì•Šì€ ë°ì´í„°ë¥¼ ê°€ì§€ê³ ë¹„ì§€ë‹ˆìŠ¤ 대화를 재시작하는 기회ì´ë‹¤)."
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr "<literal>Session</literal>ì€ ì‚¬ìš©ìž ìƒí˜¸ìž‘ìš©ì„ ê¸°ë‹¤ë¦´ ë•Œ ì–´ë–¤ 기본 JDBC 커넥션으로부터 ì—°ê²°í•´ì œëœë‹¤. ì´ ì ‘ê·¼ë²•ì€ ë°ì´í„°ë² ì´ìŠ¤ ì ‘ê·¼ì˜ ê´€ì ì—ì„œ ë³´ë©´ 가장 효율ì ì´ë‹¤. 어플리케ì´ì…˜ì€ ë²„ì „ 체킹 ë˜ëŠ” detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 재첨부하는 ê²ƒì— ê·¸ ìžì²´ ê´€ê³„í• í•„ìš”ê°€ 없거나 ê·¸ê²ƒì€ ëª¨ë“ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì—ì„œ ì¸ìŠ¤í„´ìŠ¤ë“¤ì„ 다시 로드시킬 필요가 없다."
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr "<literal>foo</literal> ê°ì²´ëŠ” ê·¸ê²ƒì´ ë¡œë“œë˜ì—ˆë˜ <literal>Session</literal>ì´ ì–´ëŠ ê²ƒì¸ì§€ë¥¼ ì—¬ì „ížˆ ì•Œê³ ìžˆë‹¤. ì´ì „ 세션 ìƒì—ì„œ í•˜ë‚˜ì˜ ìƒˆë¡œìš´ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 시작하는 ê²ƒì€ í•˜ë‚˜ì˜ ìƒˆë¡œìš´ ì»¤ë„¥ì…˜ì„ íšë“í•˜ê³ ê·¸ ì„¸ì…˜ì„ ì†Œë¹„í•œë‹¤. ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì„ 커밋(확약)시키는 ê²ƒì€ ê·¸ JDBC 커넥션으로부터 í•˜ë‚˜ì˜ ì„¸ì…˜ì„ ì—°ê²°í•´ì œì‹œí‚¤ê³ ê·¸ ì»¤ë„¥ì…˜ì„ í’€(pool)ë¡œ 반환시킬 것ì´ë‹¤. 재연결 후ì—, ë‹¹ì‹ ì´ ì—…ë°ì´íŠ¸í•˜ê³ 있지 ì•Šì€ ë°ì´í„°ì— 대한 ë²„ì „ ì²´í¬ë¥¼ ê°•ì œì‹œí‚¤ê¸° 위해서, ë‹¹ì‹ ì€ ë˜ ë‹¤ë¥¸ 트랜ìžì…˜ì— ì˜í•´ ì—…ë°ì´íŠ¸ë˜ì—ˆì„ ìˆ˜ë„ ìžˆëŠ” ìž„ì˜ì˜ ê°ì²´ë“¤ì— 대해 <literal>LockMode.READ</literal>로서 <literal>Session.lock()</literal>ì„ í˜¸ì¶œí• ìˆ˜ë„ ìžˆë‹¤. ë‹¹ì‹ ì€ ë‹¹ì‹ ì´ ì—…ë°ì´íŠ¸ ì¤‘ì¸ ìž„ì˜ì˜ ë°ì´í„°ë¥¼ ìž ê¸ˆí• í•„ìš”ê°€ 없다. 대개 ë‹¹ì‹ ì€ ë§ˆì§€ë§‰ ë°ì´í„°ë² ì´ìŠ¤ 트랜ì!
žì…˜ ì£¼ê¸°ë§Œì´ ì´ ëŒ€í™” ë‚´ì—ì„œ 행해진 ëª¨ë“ ë³€ê²½ë“¤ì„ ì‹¤ì œë¡œ ì˜ì†í™”시키는 ê²ƒì´ í—ˆìš©ë˜ë„ë¡ í•˜ê¸° 위해, í•˜ë‚˜ì˜ í™•ìž¥ëœ <literal>Session</literal>ì— ëŒ€í•´ <literal>FlushMode.MANUAL</literal>를 ì„¤ì •í• ê²ƒì´ë‹¤. 그러므로 ì˜¤ì§ ì´ ë§ˆì§€ë§‰ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ ë§Œì´ <literal>flush()</literal> 오í¼ë ˆì´ì…˜ì„ í¬í•¨í• 것ì´ê³ , ë˜í•œ 대화를 종료시키기 위해 ì„¸ì…˜ì„ <literal>close()</literal>í• ê²ƒì´ë‹¤."
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr "ë§Œì¼ ì‚¬ìš©ìžê°€ ìƒê°í•˜ëŠ”시간 ë™ì•ˆ <literal>Session</literal>ì´ ì €ìž¥ë˜ê¸°ì— 너무 í° ê²½ìš° ì´ íŒ¨í„´ì€ ë¬¸ì œì„±ì´ ìžˆë‹¤. 예를 들어 <literal>HttpSession</literal>ì€ ê°€ëŠ¥í•œ ìž‘ì€ ê²ƒìœ¼ë¡œ ìœ ì§€ë˜ì–´ì•¼ 한다. ë˜í•œ <literal>Session</literal>ì€ (필수ì˜) 첫 번째 ë ˆë²¨ ìºì‹œì´ê³ ëª¨ë“ ë¡œë“œëœ ê°ì²´ë“¤ì„ í¬í•¨í•˜ê¸° 때문ì—, 우리는 아마 ì ì€ ìš”ì²/ì‘답 ì£¼ê¸°ë“¤ì— ëŒ€í•´ì„œë§Œ ì´ ë°©ë„를 ì‚¬ìš©í• ìˆ˜ 있다. ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ëŒ€í™”ì— ëŒ€í•´ì„œë§Œ í•˜ë‚˜ì˜ <literal>Session</literal>ì„ ì‚¬ìš©í•´ì•¼ 한다. 왜ëƒí•˜ë©´ ê·¸ê²ƒì€ ë˜í•œ 곧 실없는 ë°ì´í„°ê°€ ë 것ì´ê¸° 때문ì´ë‹¤."
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr "(ì´ˆê¸°ì˜ Hibernate ë²„ì „ë“¤ì€ <literal>Session</literal>ì— ëŒ€í•œ 명시ì ì¸ ì—°ê²°í•´ì œì™€ ìž¬ì—°ê²°ì„ í•„ìš”ë¡œ í–ˆìŒì„ 노트하ë¼. 트랜ìžì…˜ì„ ì‹œìž‘í•˜ê³ ë내는 ê²ƒì´ ë™ì¼í•œ 효과를 가지므로, ì´ë“¤ ë°©ë²•ë“¤ì€ ì§„ë¶€í•˜ê²Œ ë˜ì—ˆë‹¤.)"
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr "ë˜í•œ ë‹¹ì‹ ì€ ì˜ì† ê³„ì¸µì— ëŒ€í•´ ì—°ê²°í•´ì œëœ <literal>Session</literal>ì„ ë‹«í˜€ì§„ì±„ë¡œ ìœ ì§€í•´ì•¼í•¨ì„ ë…¸íŠ¸í•˜ë¼. 달 리ë§í•´, í•˜ë‚˜ì˜ 3-tier 환경ì—ì„œ <literal>Session</literal>ì„ ì†Œìœ í•˜ëŠ”ë° EJB stateful session beanì„ ì‚¬ìš©í•˜ê³ , <literal>HttpSession</literal> ë‚´ì— ê·¸ê²ƒì„ ì €ìž¥í•˜ê¸° 위해 ê·¸ê²ƒì„ ì›¹ ê³„ì¸µì— ì „ì†¡í•˜ì§€ ë§ë¼ (ë˜ëŠ” ê·¸ê²ƒì„ ë³„ë„ì˜ í‹°ì–´ì— ì§ë ¬í™” ì‹œí‚¤ì§€ë„ ë§ë¼)."
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr "í™•ìž¥ëœ ì„¸ì…˜ 패턴, ë˜ëŠ” <emphasis>session-per-conversation</emphasis>ì€ ìžë™ì ì¸ í˜„ìž¬ 세션 컨í…스트 ê´€ë¦¬ì— ëŒ€í•´ 구현하기가 ë” ì–´ë µë‹¤. ë‹¹ì‹ ì€ ì´ë¥¼ 위해 ë‹¹ì‹ ìžì‹ ì˜ <literal>CurrentSessionContext</literal> êµ¬í˜„ì„ ê³µê¸‰í• í•„ìš”ê°€ 있으며, ì˜ˆì œë“¤ì€ Hibernate Wiki를 ë³´ë¼."
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr "Detached ê°ì²´ë“¤ê³¼ ìžë™ì ì¸ ë²„ì „í™”"
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr "ì˜ì† ì €ìž¥ì†Œì— ëŒ€í•œ ê°ê°ì˜ ìƒí˜¸ìž‘ìš©ì€ ìƒˆë¡œìš´ <literal>Session</literal>ì—ì„œ ì¼ì–´ë‚œë‹¤. 하지만 ë™ì¼í•œ ì˜ì† ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ ë°ì´í„°ë² ì´ìŠ¤ì™€ì˜ ê°ê°ì˜ ìƒí˜¸ìž‘ìš©ì— ìž¬ì‚¬ìš©ëœë‹¤. 어플리케ì´ì…˜ì€ ì›ëž˜ 로드ë˜ì—ˆë˜ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì˜ ìƒíƒœë¥¼ ë˜ ë‹¤ë¥¸ <literal>Session</literal> ë‚´ì—ì„œ ì²˜ë¦¬í•˜ê³ ë‚˜ì„œ <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, <literal>Session.merge()</literal>를 사용하여 ê·¸ê²ƒë“¤ì„ ë‹¤ì‹œ 첨부시킨다."
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr "다시, Hibernate는 flush ë™ì•ˆì— ì¸ìŠ¤í„´ìŠ¤ ë²„ì „ë“¤ì„ ì²´í¬í• 것ì´ê³ ì—…ë°ì´íŠ¸ 충ëŒì´ ë°œìƒí• ê²½ìš°ì— ì˜ˆì™¸ìƒí™©ì„ ë˜ì§ˆ 것ì´ë‹¤."
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ <literal>update()</literal>ëŒ€ì‹ ì— <literal>lock()</literal>ì„ í˜¸ì¶œí• ìˆ˜ë„ ìžˆê³ ë§Œì¼ ê·¸ ê°ì²´ê°€ 변경ë˜ì§€ 않았ìŒì„ ë‹¹ì‹ ì´ í™•ì‹ í•˜ëŠ” ê²½ìš°ì— (ë²„ì „ ì²´í‚¹ì„ ìˆ˜í–‰í•˜ê³ ëª¨ë“ ìºì‹œë“¤ì„ 무시하는) <literal>LockMode.READ</literal>를 ì‚¬ìš©í• ìˆ˜ 있다."
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr "ìžë™ì ì¸ ë²„ì „í™”ë¥¼ 맞춤화 시키기"
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "ë‹¹ì‹ ì€ <literal>optimistic-lock</literal> 매핑 ì†ì„±ì„ <literal>false</literal>ë¡œ ì„¤ì •í•¨ìœ¼ë¡œì¨ íŠ¹ì • 프로í¼í‹°ë“¤ê³¼ ì½œë ‰ì…˜ë“¤ì— ëŒ€í•œ Hibernateì˜ ìžë™ì ì¸ ë²„ì „ ì¦ê°€ë¥¼ 불가능하ë„ë¡ í• ìˆ˜ë„ ìžˆë‹¤. 그때 Hibernate는 ê·¸ 프로í¼í‹°ê°€ dirty ì¼ ê²½ìš°ì— ë” ì´ìƒ ë²„ì „ì„ ì¦ê°€ì‹œí‚¤ì§€ ì•Šì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr "리거시 ë°ì´í„°ë² ì´ìŠ¤ ìŠ¤í‚¤ë§ˆë“¤ì€ ìžì£¼ staticì´ê³ 변경ë 수 없다. ë˜ëŠ” 다른 어플리케ì´ì…˜ë“¤ì€ ë˜í•œ ë™ì¼í•œ ë°ì´í„°ë² ì´ìŠ¤ì— ì ‘ê·¼í•˜ê³ ë²„ì „ 번호들 ë˜ëŠ” 심지어 timestampë“¤ì„ ì²˜ë¦¬í•˜ëŠ” ë°©ë²•ì„ ëª¨ë¥¼ ìˆ˜ë„ ìžˆë‹¤. ë‘ ê²½ìš°ë“¤ì—ì„œ, ë²„ì „í™”ëŠ” í…Œì´ë¸” ë‚´ì˜ íŠ¹ì • ì»¬ëŸ¼ì— ì˜ì§€í• 수 없다. version ë˜ëŠ” timestamp 프로í¼í‹° 매핑 ì—†ì´ í–‰ ë‚´ì˜ ëª¨ë“ í•„ë“œë“¤ì— ëŒ€í•œ ìƒíƒœë¥¼ 비êµí•˜ì—¬ ë²„ì „ ì²´í¬ë¥¼ ê°•ì œì‹œí‚¤ê¸° 위해서, <literal><class></literal> 매핑 ì†ì— <literal>optimistic-lock=\"all\"</literal>ì„ í‘œì‹œí•˜ë¼. ë§Œì¼ Hibernateê°€ ì´ì „ ìƒíƒœì™€ 새로운 ìƒíƒœë¥¼ 비êµí• 수 ìžˆì„ ê²½ìš°ì—, 예를 들면 ë‹¹ì‹ ì´ í•˜ë‚˜ì˜ ê¸´ <literal>Session</literal>ì„ ì‚¬ìš©í•˜ê³ session-per-request-with-detached-objectsì„ ì‚¬ìš©í•˜ì§€ ì•Šì„ ê²½ìš° ì´ê²ƒì€ ê°œë…ì 으로만 ë™ìž‘í•¨ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr "때때로 í–‰í•´ì¡Œë˜ ë³€ê²½ë“¤ì´ ì¤‘ì²©ë˜ì§€ 않는 í•œ ë™ì‹œì ì¸ ë³€ê²½ì´ í—ˆìš©ë 수 있다. ë§Œì¼ <literal><class></literal>를 ë§¤í•‘í• ë•Œ ë‹¹ì‹ ì´ <literal>optimistic-lock=\"dirty\"</literal>를 ì„¤ì •í•˜ë©´, Hibernate는 flush ë™ì•ˆì— dirty í•„ë“œë“¤ì„ ë¹„êµë§Œ í• ê²ƒì´ë‹¤."
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr "ë‘ ê²½ìš°ë“¤ì—ì„œ, ì „ìš© version/timestamp ì»¬ëŸ¼ì˜ ê²½ìš° ë˜ëŠ” full/dirty í•„ë“œ 비êµì˜ 경우, Hibernate는 ë²•ì „ ì²´í¬ë¥¼ ì‹¤í–‰í•˜ê³ ì •ë³´ë¥¼ ì—…ë°ì´íŠ¸í•˜ëŠ”ë° ì—”í‹°í‹° 당 (ì ì ˆí•œ <literal>WHERE</literal> ì ˆì„ ê°€ì§„) í•œ ê°œì˜<literal>UPDATE</literal> ë¬¸ìž¥ì„ ì‚¬ìš©í•œë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ì—°ê´€ëœ ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ 재첨부를 케스케ì´ë“œ í•˜ëŠ”ë° transitive ì˜ì†ì„ ì‚¬ìš©í• ê²½ìš°, Hibernate는 불필요하게 ì—…ë°ì´íŠ¸ë“¤ì„ ì‹¤í–‰í• ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ 대개 ë¬¸ì œê°€ 아니지만, 심지어 ë³€ê²½ë“¤ì´ detached ì¸ìŠ¤í„´ìŠ¤ë“¤ì— 대해 행해지지 ì•Šì•˜ì„ ë•Œì—ë„ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì—ì„œ <emphasis>on update</emphasis> íŠ¸ë¦¬ê±°ë“¤ì´ ì‹¤í–‰ë ìˆ˜ë„ ìžˆë‹¤. ê·¸ í–‰ì„ ì—…ë°ì´íŠ¸í•˜ê¸° ì „ì— ë³€ê²½ë“¤ì´ ì‹¤ì œë¡œ ì¼ì–´ë‚¬ìŒì„ 확ì¸í•˜ê¸° 위해 ì¸ìŠ¤í„´ìŠ¤ë¥¼ <literal>SELECT</literal>하는 ê²ƒì„ Hibernateì—게 ê°•ì œì‹œí‚¤ëŠ”, <literal><class></literal> 매핑 ì†ì— <literal>!
select-before-update=\"true\"</literal>를 ì„¤ì •í•¨ìœ¼ë¡œì¨ ë‹¹ì‹ ì€ ì´ íŠ¹ì§•ì„ ë§žì¶¤í™” 시킬 수 있다."
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr "Pessimistic ìž ê¸ˆ"
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr "사용ìžë“¤ì€ ìž ê¸ˆ ë°©ë„ì— ëŒ€í•´ ê±±ì •í•˜ëŠ”ë° ë§Žì€ ì‹œê°„ì„ í• ì• í•˜í•˜ë ¤ê³ ìƒê°í•˜ì§€ 않는다. 대개 JDBC ì»¤ë„¥ì…˜ë“¤ì— ëŒ€í•œ 격리 ë ˆë²¨ì„ ì§€ì •í•˜ëŠ” 것으로 ì¶©ë¶„í•˜ê³ ê·¸ëŸ° ë‹¤ìŒ ë‹¨ìˆœížˆ ë°ì´í„°ë² ì´ìŠ¤ë¡œ 하여금 ëª¨ë“ ìž‘ì—…ì„ í–‰í•˜ë„ë¡ í•œë‹¤. 하지만 진ì¼ë³´í•œ 사용ìžë“¤ì€ 때때로 배타ì ì¸ pessimistic ìž ê¸ˆë“¤ì„ ì–»ê±°ë‚˜ ë˜ëŠ” 새로운 트랜ìžì…˜ì˜ 시작 ì‹œì— ìž ê¸ˆë“¤ì„ ë‹¤ì‹œ ì–»ê³ ìž ì›í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr "Hibernate는 ê²°ì½” 메모리 ë‚´ì— ìžˆëŠ” ê°ì²´ë“¤ì´ ì•„ë‹Œ, ë°ì´í„°ë² ì´ìŠ¤ì˜ ìž ê¸ˆ ë©”ì»¤ë‹ˆì¦˜ì„ í•ìƒ ì‚¬ìš©í• ê²ƒì´ë‹¤!"
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "<literal>LockMode</literal> í´ëž˜ìŠ¤ëŠ” Hibernateì— ì˜í•´ íšë“ë 수 있는 다른 ìž ê¸ˆ ë ˆë²¨ë“¤ì„ ì •ì˜í•œë‹¤. ìž ê¸ˆì€ ë‹¤ìŒ ë©”ì»¤ë‹ˆì¦˜ë“¤ì— ì˜í•´ 얻어진다:"
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "<literal>LockMode.WRITE</literal>는 Hibernateê°€ í•œ í–‰ì„ ì—…ë°ì´íŠ¸ 하거나 insert í• ë•Œ ìžë™ì 으로 íšë“ëœë‹¤."
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "<literal>LockMode.UPGRADE</literal>는 <literal>SELECT ... FOR UPDATE</literal> êµ¬ë¬¸ì„ ì§€ì›í•˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ ìƒì—ì„œ <literal>SELECT ... FOR UPDATE</literal>를 사용하여 명시ì ì¸ ì‚¬ìš©ìž ìš”ì² ìƒì—ì„œ 얻어질 수 있다."
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "<literal>LockMode.UPGRADE_NOWAIT</literal>는 오ë¼í´ì—ì„œ <literal>SELECT ... FOR UPDATE NOWAIT</literal>를 사용하여 명시ì ì¸ ì‚¬ìš©ìž ìš”ì² ìƒì—ì„œ 얻어질 ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr "<literal>LockMode.READ</literal>는 Hibernateê°€ 반복 가능한 ì½ê¸°(Repeatable Read) ë˜ëŠ” Serialization 격리 ë ˆë²¨ì—ì„œ ë°ì´í„°ë¥¼ ì½ì–´ë“¤ì¼ ë•Œ ìžë™ì 으로 얻어질 ìˆ˜ë„ ìžˆë‹¤. 명시ì ì¸ ì‚¬ìš©ìž ìš”ì²ì— ì˜í•´ 다시 얻어질 ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr "<literal>LockMode.NONE</literal>ì€ ìž ê¸ˆì´ ì—†ìŒì„ 나타낸다. ëª¨ë“ ê°ì²´ë“¤ì€ <literal>Transaction</literal>ì˜ ëì—ì„œ ì´ ìž ê¸ˆ 모드로 ì „í™˜ëœë‹¤. <literal>update()</literal> ë˜ëŠ” <literal>saveOrUpdate()</literal>ì— ëŒ€í•œ í˜¸ì¶œì„ í†µí•´ 세션과 ì—°ê´€ëœ ê°ì²´ë“¤ì´ ë˜í•œ ì´ ìž ê¸ˆ 모드로 시작ëœë‹¤."
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr "\"명시ì ì¸ ì‚¬ìš©ìž ìš”ì²\"ì€ ë‹¤ìŒ ë°©ë²•ë“¤ 중 하나로 표현ëœë‹¤:"
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr "<literal>LockMode</literal>를 ì§€ì •í•œ <literal>Session.load()</literal>ì— ëŒ€í•œ 호출."
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr "<literal>Session.lock()</literal>ì— ëŒ€í•œ 호출."
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr "<literal>Query.setLockMode()</literal>ì— ëŒ€í•œ 호출."
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr "ë§Œì¼ <literal>Session.load()</literal>ê°€ <literal>UPGRADE</literal> ë˜ëŠ” <literal>UPGRADE_NOWAIT</literal> 모드로 호출ë˜ê³ ,ìš”ì²ëœ ê°ì²´ê°€ ì•„ì§ ì´ ì„¸ì…˜ì— ì˜í•´ 로드ë˜ì§€ 않았다면, ê·¸ ê°ì²´ëŠ” <literal>SELECT ... FOR UPDATE</literal>를 사용하여 로드ëœë‹¤. ë§Œì¼ ìš”ì²ëœ ê²ƒì´ ì•„ë‹Œ 다소 ì œí•œì ì¸ ìž ê¸ˆìœ¼ë¡œ ì´ë¯¸ 로드ë˜ì–´ 있는 ê°ì²´ì— 대해 <literal>load()</literal>ê°€ 호출ë 경우, Hibernate는 ê·¸ ê°ì²´ì— 대해 <literal>lock()</literal>ì„ í˜¸ì¶œí•œë‹¤."
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr "ë§Œì¼ ì§€ì •ëœ ìž ê¸ˆ 모드가 <literal>READ</literal>, <literal>UPGRADE</literal> ë˜ëŠ” <literal>UPGRADE_NOWAIT</literal> ì¼ ê²½ìš°ì— <literal>Session.lock()</literal>ì€ ë²„ì „ 번호 ì²´í¬ë¥¼ 수행한다. (<literal>UPGRADE</literal> ë˜ëŠ” <literal>UPGRADE_NOWAIT</literal> ì¸ ê²½ìš°ì—, <literal>SELECT ... FOR UPDATE</literal>ê°€ 사용ëœë‹¤.)"
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr "ë§Œì¼ ë°ì´í„°ë² ì´ìŠ¤ê°€ ìš”ì²ëœ ìž ê¸ˆ 모드를 지ì›í•˜ì§€ ì•Šì„ ê²½ìš°, (예외ìƒí™©ì„ ë˜ì§€ëŠ” ëŒ€ì‹ ì—) Hibernate는 ì ì ˆí•œ 대체 모드를 ì‚¬ìš©í• ê²ƒì´ë‹¤. ì´ê²ƒì€ 어플리케ì´ì…˜ì´ ì´ì‹ ê°€ëŠ¥í• ê²ƒìž„ì„ í™•ì‹¤ížˆ 해준다."
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr "ì—°ê²° í•´ì œ 모드들"
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr "JDBC 커넥션 ê´€ë¦¬ì— ê´€í•œ Hibernateì˜ ë¦¬ê±°ì‹œ(2.x) íŠ¹ì§•ì€ ê·¸ê²ƒì´ ì²˜ìŒìœ¼ë¡œ 필요로 í–ˆì„ ë•Œ í•˜ë‚˜ì˜ <literal>Session</literal>ì´ í•˜ë‚˜ì˜ ì»¤ë„¥ì…˜ì„ íšë“í• ê²ƒì´ê³ , 그런 ë‹¤ìŒ ê·¸ ì»¤ë„¥ì…˜ì€ ê·¸ ì„¸ì…˜ì´ ë‹«í˜€ì§ˆë•Œê¹Œì§€ ë³´ê´€ëœë‹¤ëŠ” 것ì´ì—ˆë‹¤. Hibernate 3.x는 세션ì—게 ê·¸ê²ƒì˜ JDBC ì»¤ë„¥ì…˜ë“¤ì„ ì²˜ë¦¬í•˜ëŠ” ë°©ë²•ì„ ì•Œë ¤ì£¼ê¸° 위해 ì—°ê²° í•´ì œ ëª¨ë“œë“¤ì— ê´€í•œ ê°œë…ì„ ë„입했다. ë‹¤ìŒ ë…¼ì˜ëŠ” êµ¬ì„±ëœ <literal>ConnectionProvider</literal>를 통해 ì œê³µë˜ëŠ” ì»¤ë„¥ì…˜ë“¤ì— ëŒ€í•´ì„œë§Œ ì ì ˆí•˜ë‹¤ëŠ” ì ì„ ë…¸íŠ¸í•˜ë¼; 사용ìžê°€ ì œê³µí•˜ëŠ” ì»¤ë„¥ì…˜ë“¤ì€ <literal>org.hibernate.ConnectionReleaseMode</literal>ì˜ ì—´ê±°ëœ ê°’ë“¤ì— ì˜í•´ ì‹ë³„ëœë‹¤:"
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr "<literal>ON_CLOSE</literal> - 는 본질ì 으로 ìœ„ì— ì„¤ëª…ëœ ë¦¬ê±°ì‹œ 특징ì´ë‹¤. Hibernate ì„¸ì…˜ì€ ê·¸ê²ƒì´ ì–´ë–¤ JDBC ì ‘ê·¼ì„ ìˆ˜í–‰í•˜ê³ ì„¸ì…˜ì´ ë‹«í˜€ì§ˆ 때까지 ê·¸ ì»¤ë„¥ì…˜ì„ ë³´ê´€í• í•„ìš”ê°€ ìžˆì„ ë•Œ í•˜ë‚˜ì˜ ì»¤ë„¥ì…˜ì„ íšë“한다."
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr "<literal>AFTER_TRANSACTION</literal> - ì€ í•˜ë‚˜ì˜ <literal>org.hibernate.Transaction</literal>ì´ ì™„ë£Œëœ í›„ì— ì—°ê²°ë“¤ì„ í•´ì œí•˜ë¼ê³ ë§í•œë‹¤."
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr "<literal>AFTER_STATEMENT</literal> (ë˜í•œ ì ê·¹ì ì¸ í•´ì œë¼ê³ 언급ë¨) - 는 ê°ê°ì˜ ëª¨ë“ ë¬¸ìž¥ 실행 í›„ì— ì»¤ë„¥ì…˜ë“¤ì„ í•´ì œí•˜ë¼ê³ ë§í•œë‹¤. ì´ ì ê·¹ì ì¸ í•´ì œëŠ” ê·¸ ë¬¸ìž¥ì´ ì£¼ì–´ì§„ 세션과 ì—°ê´€ëœ ë¦¬ì†ŒìŠ¤ë“¤ì„ ì—´ë ¤ì§„ì±„ë¡œ 남겨둘 경우ì—는 건너뛰게(skip) ëœë‹¤; 현재 ì´ê²ƒì´ ì¼ì–´ë‚˜ëŠ” ìœ ì¼í•œ ìƒí™©ì€ <literal>org.hibernate.ScrollableResults</literal>ì˜ ì‚¬ìš©ì„ í†µí•´ì„œì´ë‹¤."
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr "ì‚¬ìš©í• í•´ì œ 모드를 ì§€ì •í•˜ê¸° 위해 구성 파ë¼ë¯¸í„° <literal>hibernate.connection.release_mode</literal>ê°€ 사용ëœë‹¤. 가능한 ê°’ë“¤ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr "<literal>auto</literal> (ë””í´íŠ¸) - ì´ ì„ íƒì€ <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> ë©”ì†Œë“œì— ì˜í•´ ë°˜í™˜ëœ í•´ì œ 모드로 위임시킨다. JTATransactionFactoryì¸ ê²½ìš°, ì´ê²ƒì€ ConnectionReleaseMode.AFTER_STATEMENT를 반환한다; JDBCTransactionFactoryì¸ ê²½ìš°, ì´ê²ƒì€ ConnectionReleaseMode.AFTER_TRANSACTIONì„ ë°˜í™˜í•œë‹¤. ì´ ì„¤ì •ì˜ ê°’ì´ ì‚¬ìš©ìž ì½”ë“œ ë‚´ì˜ ë²„ê·¸ë“¤ ê·¸ë¦¬ê³ /ë˜ëŠ” ìœ íš¨í•˜ì§€ ì•Šì€ ê°€ì •ë“¤ì„ ê°€ë¦¬í‚¤ëŠ” ê²½í–¥ì´ ìžˆìŒìœ¼ë¡œ ì¸í•´ ì´ ë””í´íŠ¸ íŠ¹ì§•ì„ ì‹¤íŒ¨ë¡œ 변경하는 ê²ƒì€ ê±°ì˜ ì¢‹ì€ ìƒê°ì´ 아니다."
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr "<literal>on_close</literal> - 는 ConnectionReleaseMode.ON_CLOSE를 사용하ë¼ê³ ë§í•œë‹¤. ì´ ì„¤ì •ì€ ì—í˜¸í™˜ì„±ì„ ìœ„í•´ 남겨졌지만, ê·¸ê²ƒì˜ ì‚¬ìš©ì€ ë§¤ìš° 권장ë˜ì§€ 않는다."
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr "<literal>after_transaction</literal> - ì€ ConnectionReleaseMode.AFTER_TRANSACTIONì„ ì‚¬ìš©í•˜ë¼ê³ ë§í•œë‹¤. ì´ ì„¤ì •ì€ JTA 환경들ì—ì„œ 사용ë˜ì§€ ì•Šì„ ê²ƒì´ë‹¤. ë˜í•œ ConnectionReleaseMode.AFTER_TRANSACTIONì¸ ê²½ìš°ì— ë§Œì¼ ì„¸ì…˜ì´ auto-commit ëª¨ë“œì— ìžˆë„ë¡ ê³ ë ¤ë 경우, ì»¤ë„¥ì…˜ë“¤ì€ ë§ˆì¹˜ í•´ì œ 모드가 AFTER_STATEMENTì¸ ê²ƒì²˜ëŸ¼ í•´ì œë ê²ƒìž„ì„ ë˜í•œ 노트하ë¼."
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr "<literal>after_statement</literal> - 는 ConnectionReleaseMode.AFTER_STATEMENT를 사용하ë¼ê³ ë§í•œë‹¤. 추가ì 으로 êµ¬ì„±ëœ <literal>ConnectionProvider</literal>는 ê·¸ê²ƒì´ ì´ ì„¤ì • (<literal>supportsAggressiveRelease()</literal>)ì„ ì§€ì›í•˜ëŠ”지 여부를 알기 위해 ì°¸ê³ ëœë‹¤. ë§Œì¼ ì§€ì›í•˜ì§€ ì•Šì„ ê²½ìš°, í•´ì œ 모드는 ConnectionReleaseMode.AFTER_TRANSACTION으로 ìž¬ì„¤ì •ëœë‹¤. ì´ ì„¤ì •ì€ ìš°ë¦¬ê°€ <literal>ConnectionProvider.getConnection()</literal>ì„ í˜¸ì¶œí• ë•Œë§ˆë‹¤ 우리가 ë™ì¼í•œ 기본 JDBC ì»¤ë„¥ì…˜ì„ ë‹¤ì‹œ 필요로 í• ìˆ˜ 있는 환경들ì—ì„œ ë˜ëŠ” 우리가 ë™ì¼í•œ ì»¤ë„¥ì…˜ì„ ì–»ëŠ” ê²ƒì— ìƒê´€ì—†ëŠ” auto-commit 환경ì—ì„œ ì˜¤ì§ ì•ˆì „í•˜ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1894 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr "Hibernate 개요"
+
+#: index.docbook:10
+msgid "Preface"
+msgstr "<title>머리ë§</title>"
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr "ì´ ìž¥ì€ Hibernate 초심ìžë¥¼ 위한 ê°œë¡ ì ì¸ íŠœí† ë¦¬ì–¼ì´ë‹¤. 우리는 메모리-ë‚´ ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 사용하는 간단한 ëª…ë ¹ ë¼ì¸ 어플리케ì´ì…˜ìœ¼ë¡œ ì‹œìž‘í•˜ê³ ë‹¨ê³„ë“¤ì„ ì´í•´í•˜ë„ë¡ ì‰½ê²Œ ê·¸ê²ƒì„ ê°œë°œí•œë‹¤."
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr "ì´ íŠœí† ë¦¬ì–¼ì€ Hibernate ì‹ ê·œ 사용ìžë“¤ì„ ì˜ë„í•˜ê³ ìžˆì§€ë§Œ Java와 SQL 지ì‹ì„ 필요로 한다. ê·¸ê²ƒì€ Michael Gloeglì´ ìž‘ì„±í•œ íŠœí† ë¦¬ì–¼ì— ê¸°ì´ˆí•˜ë©°, 우리가 명명하는 ì œ 3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì€ JDK 1.4와 5.0 ë²„ì „ìš©ì´ë‹¤. ë‹¹ì‹ ì€ JDK1.3ì— ëŒ€í•´ 다른 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 필요로 í• ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "íŠœí† ë¦¬ì–¼ìš© 소스는 <literal>doc/reference/tutorial/</literal> ë””ë ‰í† ë¦¬ ë‚´ì— ìžˆëŠ” ë°°í¬ë³¸ ë‚´ì— í¬í•¨ë˜ì–´ 있다."
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr "파트 1 - 첫 번째 Hibernate 어플리케ì´ì…˜"
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr "ë¨¼ì €, 우리는 í•œ ê°œì˜ ê°„ë‹¨í•œ 콘솔-기반 Hibernate 어플리케ì´ì…˜ì„ ìƒì„±ì‹œí‚¬ 것ì´ë‹¤. 우리는 메모리-ë‚´ ë°ì´í„°ë² ì´ìŠ¤(HSQL DB)를 사용하므로, 우리는 ì–´ë–¤ ë°ì´í„°ë² ì´ìŠ¤ 서버를 설치하지 ì•Šì•„ë„ ëœë‹¤."
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr "우리가 우리가 ìˆ˜ë°˜í•˜ê³ ìž ì›í•˜ëŠ” ì´ë²¤íŠ¸ë“¤ì„ ì €ìž¥í• ìˆ˜ 있는 ìž‘ì€ ë°ì´í„°ë² ì´ìŠ¤ 어플리케ì´ì…˜ê³¼ ì´ë“¤ ì´ë²¤íŠ¸ë“¤ì˜ í˜¸ìŠ¤íŠ¸ë“¤ì— ëŒ€í•œ ì •ë³´ë¥¼ 필요로 í•œë‹¤ê³ ê°€ì •í•˜ìž."
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr "우리가 í–‰í• ì²« 번째 ê²ƒì€ ìš°ë¦¬ì˜ ê°œë°œ ë””ë ‰í† ë¦¬ë¥¼ ì„¤ì •í•˜ê³ , 우리가 필요로 하는 ëª¨ë“ Java ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 그것 ì†ì— 집어 넣는 것ì´ë‹¤. Hibernate 웹 사ì´íŠ¸ë¡œë¶€í„° Hibernate ë°°í¬ë³¸ì„ ë‚´ë ¤ 받아ë¼. 패키지를 ì¶”ì¶œí•´ë‚´ê³ <literal>/lib</literal> ì†ì—ì„œ 발견ë˜ëŠ” ëª¨ë“ í•„ìš”í•œ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ ë‹¹ì‹ ì˜ ìƒˆë¡œìš´ 개발 ìž‘ì—… ë””ë ‰í† ë¦¬ì˜ <literal>/lib</literal> ë””ë ‰í† ë¦¬ ì†ì— 위치지워ë¼. ê·¸ê²ƒì€ ë‹¤ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr "ì´ê²ƒì€ <emphasis>ê¸€ì˜ ìž‘ì„± ì‹œì ì—ì„œ</emphasis> Hibernateì— í•„ìˆ˜ì ì¸ ìµœì†Œí•œì˜ ì„¸íŠ¸ì´ë‹¤(우리는 ë˜í•œ ë©”ì¸ ì•„ì¹´ì´ë¸Œì¸ hibernate3.jar를 복사했ìŒì„ 노트하ë¼). ë‹¹ì‹ ì´ ì‚¬ìš© ì¤‘ì¸ Hibernate ë°°í¬ë³¸ì´ ë” ë§Žê±°ë‚˜ 보다 ì ì€ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì„ 필요로 í• ìˆ˜ë„ ìžˆë‹¤. 필수 ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ê³¼ ì„ íƒì ì¸ ì œ3ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ì— 대한 추가 ì •ë³´ëŠ” Hibernate ë°°í¬ë³¸ì˜ <literal>lib/</literal> ë””ë ‰í† ë¦¬ ë‚´ì— ìžˆëŠ” <literal>README.txt</literal> 파ì¼ì„ ë³´ë¼. (ì‹¤ì œë¡œ, Log4j는 필수는 아니지만 ë§Žì€ ê°œë°œìžë“¤ì— ì˜í•´ ì„ í˜¸ëœë‹¤.)"
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr "다ìŒìœ¼ë¡œ 우리는 우리가 ë°ì´í„°ë² ì´ìŠ¤ ì†ì— ì €ìž¥ì‹œí‚¤ê³ ìž ì›í•˜ëŠ” ì´ë²¤íŠ¸ë¥¼ 표현하는 í•œ ê°œì˜ í´ëž˜ìŠ¤ë¥¼ ìƒì„±ì‹œí‚¨ë‹¤."
+
+#: index.docbook:68
+msgid "The first class"
+msgstr "첫 번째 í´ëž˜ìŠ¤"
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr "ìš°ë¦¬ì˜ ì²« 번째 ì˜ì† í´ëž˜ìŠ¤ëŠ” 몇몇 프로í¼í‹°ë“¤ì„ 가진 간단한 ìžë°”빈즈 í´ëž˜ìŠ¤ì´ë‹¤:"
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr "ë‹¹ì‹ ì€ ì´ í´ëž˜ìŠ¤ê°€ 프로í¼í‹° getter와 setter ë©”ì†Œë“œë“¤ì— ëŒ€í•œ 표준 ìžë°”빈즈 명명법들 ë¿ë§Œ ì•„ë‹ˆë¼ í•„ë“œë“¤ì— ëŒ€í•œ private ê°€ì‹œì„±ì„ ì‚¬ìš©í•˜ê³ ìžˆìŒì„ ì•Œ 수 있다. ì´ê²ƒì€ 권장ë˜ëŠ” 설계ì´ì§€ë§Œ, 필수ì ì´ì§€ëŠ” 않다. Hibernate는 ë˜í•œ í•„ë“œë“¤ì— ì§ì ‘ ì ‘ê·¼í• ìˆ˜ 있으며, accessor ë©”ì†Œë“œë“¤ì˜ ì´ì ì€ ê°•ê±´í•œ ë¦¬íŒ©í† ë§ì´ë‹¤. 아규먼트 없는 ìƒì„±ìžëŠ” reflectionì„ í†µí•´ ì´ í´ëž˜ìŠ¤ì˜ ê°ì²´ë¥¼ 초기화 시킬 필요가 있다."
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr "<literal>id</literal> 프로í¼í‹°ëŠ” 특별한 ì´ë²¤íŠ¸ë¥¼ 위한 ìœ ì¼ ì‹ë³„ìžë¥¼ ì†Œìœ í•œë‹¤. ëª¨ë“ ì˜ì† 엔티티 í´ëž˜ìŠ¤ë“¤ (보다 ëœ ì¤‘ìš”í•œ ì¢…ì† í´ëž˜ìŠ¤ë“¤ë„ 존재한다)ì€ ìš°ë¦¬ê°€ Hibernateì˜ ì „ì²´ 특징 ì§‘í•©ì„ ì‚¬ìš©í•˜ê³ ìž ì›í• ê²½ìš°ì— ê·¸ëŸ° ì‹ë³„ìž í”„ë¡œí¼í‹°ë¥¼ 필요로 í• ê²ƒì´ë‹¤. 사실 ëŒ€ë¶€ë¶„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤(특히 웹 어플리케ì´ì…˜ë“¤)ì€ ì‹ë³„ìžì— ì˜í•´ ê°ì²´ë“¤ì„ êµ¬ë¶„ì§€ì„ í•„ìš”ê°€ 있어서, ë‹¹ì‹ ì€ ì´ê²ƒì„ ì–´ë–¤ ì œì•½ì ì´ë¼ê¸° 보다는 í•˜ë‚˜ì˜ íŠ¹ì§•ìœ¼ë¡œ ê°„ì£¼í• ê²ƒì´ë‹¤. 하지만 우리는 대개 ê°ì²´ì˜ í•ë“±(identity)를 처리하지 않으므로, setter 메소드는 privateì´ì–´ì•¼ 한다. ê°ì²´ê°€ ì €ìž¥ë ë•Œ, Hibernate는 단지 ì‹ë³„ìžë“¤ì„ í• ë‹¹í• ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ Hibernateê°€ public, private, protected ì ‘ê·¼ìž ë©”ì†Œë“œë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ (public, private, protected) 필드들ì—ë„ ì§ì ‘ ì ‘ê·¼í• ìˆ˜ 있ìŒì„ ì•Œ 수 있다. ì„!
íƒì€ ë‹¹ì‹ ì—게 ë‹¬ë ¤ 있으며, ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ì„¤ê³„ì— ì 합하ë„ë¡ ê·¸ê²ƒì„ ë¶€í•©ì‹œí‚¬ 수 있다."
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr "아규먼트 없는 ìƒì„±ìžëŠ” ëª¨ë“ ì˜ì† í´ëž˜ìŠ¤ë“¤ì— 대한 필요조건ì´ë‹¤; Hibernate는 ë‹¹ì‹ ì„ ìœ„í•´ Java Reflectionì„ ì‚¬ìš©í•˜ì—¬ ê°ì²´ë“¤ì„ ìƒì„±ì‹œì¼œì•¼ 한다. 하지만 ìƒì„±ìžëŠ” private ì¼ ìˆ˜ ìžˆê³ , 패키지 ê°€ì‹œì„±ì€ ëŸ°íƒ€ìž„ 프ë½ì‹œ ìƒì„±ê³¼ ë°”ì´íŠ¸ì½”ë“œ 방편 없는 효율ì ì¸ ë°ì´í„° ê²€ìƒ‰ì— í•„ìš”í•˜ë‹¤."
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr "ì´ Java 소스 파ì¼ì„ 개발 í´ë” ë‚´ì˜ <literal>src</literal>ë¡œ ëª…ëª…ëœ ë””ë ‰í† ë¦¬ ì†ì— 있는 위치지워ë¼. ì´ì œ ê·¸ ë””ë ‰í† ë¦¬ëŠ” 다ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr "ë‹¤ìŒ ë‹¨ê³„ì—ì„œ, 우리는 Hiberanteì—게 ì´ ì˜ì† í´ëž˜ìŠ¤ì— 대해 ì•Œë ¤ 준다."
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr "The mapping file"
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr "Hibernate는 ì˜ì† í¬ëž˜ìŠ¤ë“¤ì— 대한 ê°ì²´ë“¤ì„ ë¡œë“œì‹œí‚¤ê³ ì €ìž¥ì‹œí‚¤ëŠ” ë°©ë²•ì„ ì•Œ 필요가 있다. ì´ê³³ì€ Hibernate 매핑 파ì¼ì´ ì—í• ì„ í–‰í•˜ëŠ” ê³³ì´ë‹¤. 매핑 파ì¼ì€ Hibernateê°€ ì ‘ê·¼í•´ì•¼ 하는 ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì˜ í…Œì´ë¸”ì´ ë¬´ì—‡ì¸ì§€, ê·¸ë¦¬ê³ ê·¸ê²ƒì´ ì‚¬ìš©í•´ì•¼ 하는 ê·¸ í…Œì´ë¸” ë‚´ì˜ ì»¬ëŸ¼ë“¤ì´ ë¬´ì—‡ì¸ì§€ë¥¼ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤."
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr "매핑 파ì¼ì˜ 기본 구조는 다ìŒê³¼ 같다:"
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr "Hibernate DTD는 매우 ì •êµí•˜ë‹¤. ë‹¹ì‹ ì€ ë‹¹ì‹ ì˜ íŽ¸ì§‘ê¸° ë˜ëŠ” IDE ë‚´ì—ì„œ XML 매핑 요소들과 ì†ì„±ë“¤ì— 대한 ìžë™ 완성 ê¸°ëŠ¥ì„ ìœ„í•´ ê·¸ê²ƒì„ ì‚¬ìš©í• ìˆ˜ 있다. ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì˜ í…스트 편집기 ë‚´ì— DTD 파ì¼ì„ ì—´ 수 ìžˆì„ ê²ƒì´ë‹¤ - ê·¸ê²ƒì€ ëª¨ë“ ìš”ì†Œë“¤ê³¼ ì†ì„±ë“¤ì— 대한 ì „ì²´ìƒì„ ì–»ê³ ë””í´íŠ¸ë“¤ ë¿ë§Œ ì•„ë‹ˆë¼ ëª‡ëª‡ 주ì„ë“¤ì„ ë³´ëŠ” 가장 ì†ì‰¬ìš´ 방법ì´ë‹¤. Hibernate는 웹으로부터 DTD 파ì¼ì„ 로드시키지 않지만, ë¨¼ì € 어플리케ì´ì…˜ì˜ classpath 경로로부터 ê·¸ê²ƒì„ ë¨¼ì € ë£©ì—…í• ê²ƒìž„ì„ ë…¸íŠ¸í•˜ë¼. DTD 파ì¼ì€ <literal>hibernate3.jar</literal> ì†ì— í¬í•¨ë˜ì–´ ìžˆì„ ë¿ë§Œ ì•„ë‹ˆë¼ Hibernate ë°°í¬ë³¸ì˜ <literal>src/</literal> ë””ë ‰í† ë¦¬ ì†ì— í¬í•¨ë˜ì–´ 있다."
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr "우리는 코드를 간략화 시키기 위해 ìž¥ëž˜ì˜ ì˜ˆì œì—ì„œ DTD ì„ ì–¸ì„ ìƒëžµí• 것ì´ë‹¤. ê·¸ê²ƒì€ ë¬¼ë¡ ì˜µì…˜ì´ ì•„ë‹ˆë‹¤."
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr "ë‘ ê°œì˜ <literal>hibernate-mapping</literal> 태그들 사ì´ì— <literal>class</literal> 요소를 í¬í•¨ì‹œì¼œë¼. ëª¨ë“ ì˜ì† 엔티티 í´ëž˜ìŠ¤ë“¤(다시금 ì¢…ì† í´ëž˜ìŠ¤ë“¤ì¼ 수 ìžˆê³ , ê·¸ê²ƒì€ ì²«ë²ˆì§¸-ê¸‰ì˜ ì—”í‹°í‹°ë“¤ì´ ì•„ë‹ˆë‹¤)ì€ SQL ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì˜ í…Œì´ë¸”ì— ëŒ€í•œ 그런 ë§¤í•‘ì„ í•„ìš”ë¡œ 한다:"
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr "지금까지 우리는 ê·¸ í…Œì´ë¸” ë‚´ì— ìžˆëŠ” í•œ í–‰ì— ì˜í•´ í‘œí˜„ëœ ê°ê°ì˜ ì¸ìŠ¤í„´ìŠ¤ì¸, í´ëž˜ìŠ¤ì˜ ê°ì²´ë¥¼ ì˜ì†í™” ì‹œí‚¤ê³ ë¡œë“œì‹œí‚¤ëŠ” ë°©ë²•ì„ Hibernateì—게 ì•Œë ¤ì£¼ì—ˆë‹¤. ì´ì œ ìš°ë¦°ëŠ í…Œì´ë¸” 프ë¼ì´ë¨¸ë¦¬ í‚¤ì— ëŒ€í•œ ìœ ì¼ ì‹ë³„ìž í”„ë¡œí¼í‹° ë§¤í•‘ì„ ê³„ì† í–‰í•œë‹¤. 게다가 우리는 ì´ ì‹ë³„ìžë¥¼ 처리하는 ê²ƒì— ì£¼ì˜ë¥¼ 기울ì´ê³ ìž ì›í•˜ì§€ 않으므로, 우리는 대용 키 프ë¼ì´ë¨¸ë¦¬ 키 ì»¬ëŸ¼ì— ëŒ€í•œ Hibernateì˜ ì‹ë³„ìž ìƒì„± ë°©ë„를 구성한다:"
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr "<literal>id</literal> 요소는 ì‹ë³„ìž í”„ë¡œí¼í‹°ì˜ ì„ ì–¸ì´ê³ , <literal>name=\"id\"</literal>는 Java 프로í¼í‹°ì˜ ì´ë¦„ì„ ì„ ì–¸í•œë‹¤ - Hibernate는 ê·¸ 프로í¼í‹°ì— ì ‘ê·¼í•˜ëŠ”ë° getter ë° setter ë©”ì†Œë“œë“¤ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. column ì†ì„±ì€ 우리가 <literal>EVENTS</literal> í…Œì´ë¸”ì˜ ì–´ëŠ ì»¬ëŸ¼ì„ ì´ í”„ë¼ì´ë¨¸ë¦¬ 키로 사용하는지를 Hibernateì—게 ì•Œë ¤ì¤€ë‹¤. ë‚´í¬ëœ <literal>generator</literal> 요소는 ì‹ë³„ìž ìƒì„± ë°©ë„를 ì§€ì •í•˜ë©°, ì´ ê²½ìš°ì— ìš°ë¦¬ëŠ” <literal>increment</literal>를 ì‚¬ìš©í–ˆê³ , ê·¸ê²ƒì€ ëŒ€ê°œ 테스팅(ê³¼ íŠœí† ë¦¬ì–¼ë“¤)ì— ìœ ìš©í•œ 매우 간단한 메모리-ë‚´ ìˆ«ìž ì¦ê°€ 방법ì´ë‹¤. Hibernate는 ë˜í•œ ì „ì—ì 으로 ìœ ì¼í•œ ë°ì´í„°ë² ì´ìŠ¤ì— ì˜í•´ ìƒì„±ëœ ì‹ë³„ìž ë¿ë§Œ ì•„ë‹ˆë¼ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— ì˜í•´ í• ë‹¹ëœ ì‹ë³„ìž(ë˜ëŠ” ë‹¹ì‹ ì´ í™•ìž¥ìœ¼ë¡œ 작성한 ì–´ë–¤ ë°©ë„)를 지ì›í•œë‹¤."
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr "마지막으로 우리는 매핑 íŒŒì¼ ì†ì—ì„œ í´ëž˜ìŠ¤ì˜ ì˜ì† 프로í¼í‹°ë“¤ì— 대한 ì„ ì–¸ë“¤ì„ í¬í•¨í•œë‹¤. ë””í´íŠ¸ë¡œ, í´ëž˜ìŠ¤ì˜ 프로í¼í‹°ë“¤ì€ ì˜ì†ì ì¸ ê²ƒìœ¼ë¡œ 간주ë˜ì§€ 않는다:"
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr "<literal>id</literal> ìš”ì†Œì˜ ê²½ìš°ì²˜ëŸ¼, <literal>property</literal> ìš”ì†Œì˜ <literal>name</literal> ì†ì„±ì€ ì‚¬ìš©í• getter ë° setter ë©”ì†Œë“œë“¤ì´ ì–´ëŠ ê²ƒì¸ì§€ë¥¼ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤. ë”°ë¼ì„œ ì´ ê²½ìš°ì— Hibernate는 <literal>getDate()/setDate()</literal> ë¿ë§Œ ì•„ë‹ˆë¼ <literal>getTitle()/setTitle()</literal>ì„ ì°¾ê²Œ ë 것ì´ë‹¤."
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr "<literal>date</literal> 프로í¼í‹° ë§¤í•‘ì€ <literal>column</literal> ì†ì„±ì„ í¬í•¨í•˜ëŠ”ë°, 왜 <literal>title</literal>ì€ <literal>column</literal> ì†ì„±ì„ í¬í•¨í•˜ì§€ 않는가? <literal>column</literal> ì†ì„±ì´ ì—†ì„ ê²½ìš° Hibernate는 ë””í´íŠ¸ë¡œ 컬럼 ì´ë¦„으로서 프로í¼í‹° ì´ë¦„ì„ ì‚¬ìš©í•œë‹¤. ì´ê²ƒì€ ì— ëŒ€í•´ 잘 ë™ìž‘한다. 하지만 <literal>date</literal>는 ëŒ€ë¶€ë¶„ì˜ ë°ì´í„°ë² ì´ìŠ¤ì—ì„œ ì˜ˆì•½ëœ í‚¤ì›Œë“œì´ì–´ì„œ, 우리는 ê·¸ê²ƒì„ ë‹¤ë¥¸ ì´ë¦„으로 ë” ì¢‹ê²Œ 매핑 시킨다."
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr "ë‹¤ìŒ í¥ë¯¸ë¡œìš´ ì ì€ <literal>title</literal> 매핑 ë˜í•œ <literal>type</literal> ì†ì„±ì„ 갖지 않는다. 우리가 매핑파ì¼ë“¤ ì†ì—ì„œ ì„ ì–¸í•˜ê³ ì‚¬ìš©í•˜ëŠ” íƒ€ìž…ë“¤ì€ ë‹¹ì‹ ì´ ì˜ˆìƒí•˜ëŠ” Java ë°ì´í„° íƒ€ìž…ë“¤ì´ ì•„ë‹ˆë‹¤. ê·¸ê²ƒë“¤ì€ ë˜í•œ SQL ë°ì´í„°ë² ì´ìŠ¤ íƒ€ìž…ë“¤ë„ ì•„ë‹ˆë‹¤. ì´ë“¤ íƒ€ìž…ë“¤ì€ ì´ë¥¸ë°” <emphasis>Hibernate 매핑 타입들</emphasis>, 즉 Java 타입들로부터 SQL 타입들로 변환ë 수 ìžˆê³ ë°˜ëŒ€ë¡œ SQL 타입들로부터 Java 타입들로 매핑ë 수 있는 컨버터들ì´ë‹¤. 다시ë§í•´, <literal>type</literal> ì†ì„±ì´ 매핑 ì†ì— 존재하지 ì•Šì„ ê²½ìš° Hibernate는 ì •í™•í™˜ 변환 ë° ë§¤í•‘ 타입 ê·¸ ìžì²´ë¥¼ ê²°ì •í•˜ë ¤ê³ ì‹œë„í• ê²ƒì´ë‹¤. 몇몇 경우들ì—ì„œ (Java í´ëž˜ìŠ¤ì— 대한 Reflectionì„ ì‚¬ìš©í•˜ëŠ”) ì´ ìžë™ì ì¸ ê²€ì¶œì€ ë‹¹ì‹ ì´ ì˜ˆìƒí•˜ê±°ë‚˜ 필요로 하는 ë””í´íŠ¸ë¥¼ 갖지 ì•Šì„ ìˆ˜ë„ ìžˆë‹¤. ì´ê²ƒì€ <literal>date</literal> 프로í¼í!
‹°ë¥¼ 가진 경우ì´ë‹¤. Hibernate는 ê·¸ 프로í¼í‹°ê°€ SQL <literal>date</literal> 컬럼, <literal>timestamp</literal> 컬럼 ë˜ëŠ” <literal>time</literal> 컬럼 중 ì–´ëŠ ê²ƒìœ¼ë¡œ 매핑ë˜ì–´ì•¼ 하는지를 ì•Œ 수가 없다. 우리는 <literal>timestamp</literal> 컨버터를 가진 프로í¼í‹°ë¥¼ ë§¤í•‘í•¨ìœ¼ë¡œì¨ ì „ì²´ ë‚ ì§œì™€ 시간 ì •ë³´ë¥¼ ë³´ì¡´í•˜ê³ ì‹¶ë‹¤ê³ ì„ ì–¸í•œë‹¤."
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr "ë‹¤ìŒ ë§¤í•‘ 파ì¼ì€ <literal>Event</literal> Java í´ëž˜ìŠ¤ 소스 파ì¼ê³¼ ê°™ì€ ë””ë ‰í† ë¦¬ ì†ì— <literal>Event.hbm.xml</literal>로서 ì €ìž¥ë 것ì´ë‹¤. 매핑 파ì¼ë“¤ì— 대한 네ì´ë°ì€ ìž„ì˜ì ì¼ ìˆ˜ 있지만, ì ‘ë¯¸ì‚¬ <literal>hbm.xml</literal>ì€ Hibernate ê°œë°œìž ê³µë™ì²´ ë‚´ì—ì„œ ì»¨ë²¤ì…˜ì´ ë˜ì—ˆë‹¤. ë””ë ‰í† ë¦¬ 구조는 ì´ì œ 다ìŒê³¼ ê°™ì„ ê²ƒì´ë‹¤:"
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr "우리는 Hibernateì˜ ë©”ì¸ êµ¬ì„±ì„ ê³„ì† í–‰í•œë‹¤."
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr "Hibernate 구성"
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr "우리는 ì´ì œ ì ì ˆí•œ ê³³ì— í•œ ê°œì˜ ì˜ì† í´ëž˜ìŠ¤ì™€ ê·¸ê²ƒì˜ ë§¤í•‘ 파ì¼ì„ ê°–ê³ ìžˆë‹¤. Hibernate를 êµ¬ì„±í• ì°¨ë¡€ì´ë‹¤. 우리가 ì´ê²ƒì„ 행하기 ì „ì—, 우리는 ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 필요로 í• ê²ƒì´ë‹¤. ìžë°” ê¸°ë°˜ì˜ ë©”ëª¨ë¦¬-ë‚´ SQL DBMSì¸ HSQL DB는 HSQL DB 웹 사ì´íŠ¸ì—ì„œ ë‚´ë ¤ë°›ì„ ìˆ˜ 있다. ì‹¤ì œë¡œ, ë‹¹ì‹ ì€ ì´ ë‹¤ìš´ë¡œë“œì—ì„œ ì˜¤ì§ <literal>hsqldb.jar</literal> ë§Œì„ í•„ìš”ë¡œ 한다. 개발 í´ë”ì˜ <literal>lib/</literal> ë””ë ‰í† ë¦¬ ì†ì— ì´ íŒŒì¼ì„ 위치지워ë¼."
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr "개발 ë””ë ‰í† ë¦¬ì˜ ë£¨íŠ¸ì— <literal>data</literal>ë¡œ ëª…ëª…ëœ ë””ë ‰í† ë¦¬ë¥¼ ìƒì„±ì‹œì¼œë¼ - ì´ ë””ë ‰í† ë¦¬ëŠ” HSQL DBê°€ ê·¸ê²ƒì˜ ë°ì´í„° 파ì¼ë“¤ì„ ì €ìž¥í•˜ê²Œ ë 장소ì´ë‹¤. ì´ì œ ì´ ë°ì´í„° ë””ë ‰í† ë¦¬ì—ì„œ <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal>를 실행시켜서 ë°ì´í„°ë² ì´ìŠ¤ë¥¼ 시작시켜ë¼. ë‹¹ì‹ ì€ ê·¸ê²ƒì´ ì‹œìž‘ë˜ê³ ì´ê²ƒì€ ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì´ ë‚˜ì¤‘ì— ì—°ê²°í•˜ê²Œ ë 장소ì¸, í•˜ë‚˜ì˜ TCP/IP ì†Œì¼“ì— ë°”ì¸ë“œ ë˜ëŠ” ê²ƒì„ ë³¼ 수 있다. ë§Œì¼ ì´ íŠœí† ë¦¬ì–¼ ë™ì•ˆì— ë‹¹ì‹ ì´ ìƒˆ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ì‹œìž‘í•˜ê³ ìž ì›í• 경우, HSQL DB를 ì…§ë‹¤ìš´ì‹œí‚¤ê³ (왼ë„ìš°ì—ì„œ <literal>CTRL + C</literal>를 눌러ë¼), <literal>data/</literal> ë””ë ‰í† ë¦¬ ë‚´ì— ìžˆëŠ” ëª¨ë“ íŒŒì¼ë“¤ì„ ì‚ì œí•˜ê³ ë‹¤ì‹œ HSQL DB를 시작하ë¼."
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr "Hibernate는 ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì—ì„œ ì´ ë°ì´í„°ë² ì´ìŠ¤ì— 연결하는 계층ì´ê³ , ë”°ë¼ì„œ ê·¸ê²ƒì€ ì»¤ë„¥ì…˜ ì •ë³´ë¥¼ 필요로 한다. ì»¤ë„¥ì…˜ë“¤ì€ ë§ˆì°¬ê°€ì§€ë¡œ 구성ë˜ì–´ì•¼ 하는 í•˜ë‚˜ì˜ JDBC 커넥션 í’€ì„ í†µí•´ 행해진다. Hibernate ë°°í¬ë³¸ì€ 몇몇 오픈 소스 JDBC 커넥션 í’€ë§ ë„êµ¬ë“¤ì„ í¬í•¨í•˜ê³ 있지만, ì´ íŠœí† ë¦¬ì–¼ì—서는 Hibernateì— ì˜í•´ 미리 ë¹Œë“œëœ ì»¤ë„¥ì…˜ í’€ë§ì„ ì‚¬ìš©í• ê²ƒì´ë‹¤. ë‹¹ì‹ ì´ í•„ìˆ˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ ë‹¹ì‹ ì˜ classpath ì†ì— 복사해야 í•˜ê³ ë§Œì¼ ë‹¹ì‹ ì´ ì œí’ˆ-íŠ¹ì§•ì˜ ì œ3ì˜ JDBC í’€ë§ ì†Œí”„íŠ¸ì›¨ì–´ë¥¼ ì‚¬ìš©í•˜ê³ ìž ì›í• 경우ì—는 다른 커넥션 í’€ë§ ì„¤ì •ë“¤ì„ ì‚¬ìš©í•´ì•¼ í•¨ì„ ë…¸íŠ¸í•˜ë¼."
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr "Hibernateì˜ êµ¬ì„±ì„ ìœ„í•´, 우리는 í•œ ê°œì˜ ê°„ë‹¨í•œ <literal>hibernate.properties</literal> 파ì¼, í•œ ê°œì˜ ì•½ê°„ ë” ì„¸ë ¨ëœ <literal>hibernate.cfg.xml</literal> 파ì¼, ë˜ëŠ” 심지어 ì™„ì „í•œ 프로그램 ìƒì˜ ì„¤ì •ì„ ì‚¬ìš©í• ìˆ˜ 있다. ëŒ€ë¶€ë¶„ì˜ ì‚¬ìš©ìžë“¤ì€ XMl 구성 파ì¼ì„ ì„ í˜¸í•œë‹¤:"
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr "ì´ XML êµ¬ì„±ì´ ë‹¤ë¥¸ DTD를 ì‚¬ìš©í•¨ì„ ë…¸íŠ¸í•˜ë¼. 우리는 Hibernateì˜ <literal>SessionFactory</literal> -íŠ¹ì • ë°ì´í„°ë² ì´ìŠ¤ì— 대해 ì±…ìž„ì´ ìžˆëŠ” ì „ì— íŒ©í† ë¦¬-를 구성한다. ë§Œì¼ ë‹¹ì‹ ì´ ì—¬ëŸ¬ ë°ì´í„°ë² ì´ìŠ¤ë“¤ì„ ê°–ê³ ìžˆë‹¤ë©´, (보다 쉬운 ì‹œìž‘ì„ ìœ„í•´) 몇 ê°œì˜ êµ¬ì„± 파ì¼ë“¤ ì†ì— 여러 ê°œì˜ <literal><session-factory></literal> êµ¬ì„±ë“¤ì„ ì‚¬ìš©í•˜ë¼."
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr "ì²˜ìŒ ë„¤ ê°œì˜ <literal>property</literal> ìš”ì†Œë“¤ì€ JDBC ì»¤ë„¥ì…˜ì„ ìœ„í•œ 필수 êµ¬ì„±ì„ í¬í•¨í•œë‹¤. dialect <literal>property</literal> 요소는 Hibernateê°€ ë°œìƒì‹œí‚¤ëŠ” 특별한 SQL ì´í˜•(ç•°å½¢)ì„ ì§€ì •í•œë‹¤. <literal>hbm2ddl.auto</literal> ì˜µì…˜ì€ -ì§ì ‘ ë°ì´í„°ë² ì´ìŠ¤ ì†ìœ¼ë¡œ- ë°ì´í„°ë² ì´ìŠ¤ ìŠ¤í‚¤ë§ˆì˜ ìžë™ì ì¸ ìƒì„±ì„ 활성화 시킨다. ë¬¼ë¡ ì´ê²ƒì€ (config ì˜µì…˜ì„ ì œê±°í•¨ìœ¼ë¡œì¨) 비활성화 시킬 수 있거나 <literal>SchemaExport</literal> Ant 태스í¬ì˜ ë„움으로 파ì¼ë¡œ 리다ì´ë ‰íŠ¸ ë 수 있다. 마지막으로 우리는 ì˜ì† í´ëž˜ìŠ¤ë“¤ì„ 위한 매핑 파ì¼(들)ì„ ì¶”ê°€ì‹œí‚¨ë‹¤."
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr "ì´ íŒŒì¼ì„ 소스 ë””ë ‰í† ë¦¬ ì†ìœ¼ë¡œ ë³µì‚¬í•˜ê³ , ë”°ë¼ì„œ ê·¸ê²ƒì€ classpathì˜ ë£¨íŠ¸ì—ì„œ ëë‚ ê²ƒì´ë‹¤. Hibernate는 시작 ì‹œì— classpathì˜ ë£¨íŠ¸ì—ì„œ <literal>hibernate.cfg.xml</literal>ë¡œ ëª…ëª…ëœ íŒŒì¼ì„ ìžë™ì 으로 찾는다."
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr "Ant로 빌드하기"
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr "우리는 ì´ì œ Antë¡œ íŠœí† ë¦¬ì–¼ì„ ë¹Œë“œí• ê²ƒì´ë‹¤. ë‹¹ì‹ ì€ Ant를 ì„¤ì¹˜í• í•„ìš”ê°€ ìžˆì„ ê²ƒì´ë‹¤ - <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant ë‚´ë ¤ë°›ê¸° 페ì´ì§€</ulink>ì—ì„œ Ant를 얻어ë¼. Ant를 설치하는 ë°©ë²•ì€ ì—¬ê¸°ì„œ 다루지 ì•Šì„ ê²ƒì´ë‹¤. <ulink url=\"http://ant.apache.org/manual/index.html\">Ant 매뉴얼</ulink>ì„ ì°¸ì¡°í•˜ê¸¸ 바란다. ë‹¹ì‹ ì´ Ant를 설치한 후ì—, 우리는 ë¹Œë“œíŒŒì¼ ìƒì„±ì„ ì‹œìž‘í• ìˆ˜ 있다. ê·¸ê²ƒì€ <literal>build.xml</literal>ë¡œ 명명ë˜ê³ 개발 ë””ë ‰í† ë¦¬ ì†ì— ì§ì ‘ 위치ë 것ì´ë‹¤."
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr "기본 빌드 파ì¼ì€ 다ìŒê³¼ 같다:"
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr "ì´ê²ƒì€ <literal>.jar</literal>ë¡œ ë나는 lib ë””ë ‰í† ë¦¬ ë‚´ì— ìžˆëŠ” ëª¨ë“ íŒŒì¼ë“¤ì„ 컴파ì¼ì— 사용ë˜ëŠ” classpathì— ì¶”ê°€í•˜ë„ë¡ Antì—게 ì•Œë ¤ì¤„ 것ì´ë‹¤. ê·¸ê²ƒì€ ë˜í•œ ëª¨ë“ ë¹„-Java 소스 파ì¼ë“¤ì„ ëŒ€ìƒ ë””ë ‰í† ë¦¬ë¡œ ë³µì‚¬í• ê²ƒì´ë‹¤. 예를 들면, 구성 ë° Hibernate 매핑 파ì¼ë“¤. ë§Œì¼ ë‹¹ì‹ ì´ Ant를 ì´ì œ ì‹¤í–‰í• ê²½ìš°, ë‹¹ì‹ ì€ ë‹¤ìŒ ì¶œë ¥ì„ ì–»ê²Œ ë 것ì´ë‹¤:"
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr "시작과 helper들"
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr "몇몇 <literal>Event</literal> ê°ì²´ë“¤ì„ ë¡œë“œì‹œí‚¤ê³ ì €ìž¥í• ì°¨ë¡€ì´ì§€ë§Œ, ë¨¼ì € 우리는 ì–´ë–¤ ì¸í”„ë¼ìŠ¤íŠ¸ëŸì²˜ 코드로 ì„¤ì •ì„ ì™„ë£Œí•´ì•¼ 한다. 우리는 Hibernate를 시작해야 한다. ì´ ì‹œìž‘ì€ ì „ì— <literal>SessionFactory</literal> ê°ì²´ë¥¼ ë¹Œë“œí•˜ê³ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì—ì„œ ìš©ì´í•œ ì ‘ê·¼ì„ ìœ„í•´ ê·¸ê²ƒì„ ì–´ë–¤ ê³³ì— ì €ìž¥í•˜ëŠ” ê²ƒì„ í¬í•¨í•œë‹¤. <literal>SessionFactory</literal>는 새로운 <literal>Session</literal>ë“¤ì„ ì—´ 수 있다. <literal>Session</literal>ì€ ìž‘ì—…ì˜ ë‹¨ì¼-ì“°ë ˆë“œ 단위를 표현하며, <literal>SessionFactory</literal>는 한번 초기화 ë˜ëŠ” í•˜ë‚˜ì˜ thread-safe ì „ì— ê°ì²´ì´ë‹¤."
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr "우리는 ì‹œìž‘ì„ ì²˜ë¦¬í•˜ê³ <literal>Session</literal> 처리를 편리하게 해주는 <literal>HibernateUtil</literal> helper í´ëž˜ìŠ¤ë¥¼ ìƒì„±ì‹œí‚¬ 것ì´ë‹¤. ì´ë¥¸ë°” <emphasis>ThreadLocal Session</emphasis> íŒ¨í„´ì´ ì—¬ê¸°ì„œ ìœ ìš©í•˜ë©°, 우리는 í˜„ìž¬ì˜ ìž‘ì—… 단위를 í˜„ìž¬ì˜ ì“°ë ˆë“œì™€ 연관지워 ìœ ì§€í•œë‹¤. êµ¬í˜„ì„ ì‚´íŽ´ë³´ìž:"
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr "ì´ í´ëž˜ìŠ¤ëŠ” (í´ëž˜ìŠ¤ê°€ 로드ë ë•Œ JVMì— ì˜í•´ 한번 호출ë˜ëŠ”) ê·¸ê²ƒì˜ static ì´ˆê¸°ìž ë‚´ì— ì „ì— <literal>SessionFactory</literal>를 ì‚°ì¶œí• ë¿ë§Œ ì•„ë‹ˆë¼ ë˜í•œ 현재 ì“°ë ˆë“œì— ëŒ€í•œ <literal>Session</literal>ì„ ì†Œìœ í•˜ëŠ” <literal>ThreadLocal</literal> 변수를 갖는다. ë‹¹ì‹ ì´ <literal>HibernateUtil.getCurrentSession()</literal>ì„ í˜¸ì¶œí•˜ëŠ” ì‹œì ì—는 ë¬¸ì œê°€ 없으며, ê·¸ê²ƒì€ í•ìƒ ë™ì¼ ì“°ë ˆë“œ ë‚´ì— ë™ì¼í•œ Hibernate ìž‘ì—… 단위를 ë°˜í™˜í• ê²ƒì´ë‹¤. <literal>HibernateUtil.closeSession()</literal>ì— ëŒ€í•œ í˜¸ì¶œì€ ì“°ë ˆë“œì™€ 현재 ì—°ê´€ë˜ì–´ 있는 ìž‘ì—… 단위를 종료시킨다."
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr "ë‹¹ì‹ ì´ ì´ helper를 사용하기 ì „ì— thread-local ë³€ìˆ˜ë“¤ì— ëŒ€í•œ Java ê°œë…ì„ í™•ì‹¤ížˆ ì´í•´í•˜ë„ë¡ í•˜ë¼. 보다 ê°•ë ¥í•œ <literal>HibernateUtil</literal> helper는 http://caveatemptor.hibernate.org/ì— ìžˆëŠ” <literal>CaveatEmptor</literal> ë¿ë§Œ ì•„ë‹ˆë¼ \"Java Persistence with Hibernate\" ì±…ì—ì„œ ì°¾ì„ ìˆ˜ 있다. ë‹¹ì‹ ì´ J2EE 어플리케ì´ì…˜ 서버 ë‚´ì— Hibernate를 ë°°ì¹˜í• ê²½ìš°ì— ì´ í´ëž˜ìŠ¤ëŠ” 필수ì ì´ì§€ 않다: í•˜ë‚˜ì˜ <literal>Session</literal>ì€ í˜„ìž¬ì˜ JTA 트랜ìžì…˜ì— ìžë™ì 으로 ë°”ì¸ë“œ ë 것ì´ê³ ë‹¹ì‹ ì€ JNDI를 통해 <literal>SessionFactory</literal>를 ë£©ì—…í• ìˆ˜ 있다. ë§Œì¼ ë‹¹ì‹ ì´ JBoss AS를 ì‚¬ìš©í• ê²½ìš°, Hibernate는 관리ë˜ëŠ” 시스템 서비스로서 배치ë 수 ìžˆê³ <literal>SessionFactory</literal>를 JNDI ì´ë¦„ì— ìžë™ì 으로 ë°”ì¸ë“œì‹œí‚¬ 수 ìžˆì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr "개발 소스 ë””ë ‰í† ë¦¬ ì†ì— <literal>HibernateUtil.java</literal> 를 ìœ„ì¹˜ì§€ìš°ê³ , 다ìŒìœ¼ë¡œ <literal>Event.java</literal>를 위치지워ë¼:"
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr "ì´ê²ƒì€ ë¬¸ì œ ì—†ì´ ë‹¤ì‹œ ì»´íŒŒì¼ ë 것ì´ë‹¤. 우리는 마지막으로 로깅 ì‹œìŠ¤í…œì„ êµ¬ì„±í• í•„ìš”ê°€ 있다 - Hibernate는 commons logging를 ì‚¬ìš©í•˜ê³ Log4j와 JDK 1.4 사ì´ì˜ ì„ íƒì€ ë‹¹ì‹ ì˜ ëª«ìœ¼ë¡œ 남겨둔다. ëŒ€ë¶€ë¶„ì˜ ê°œë°œìžë“¤ì€ Log4j를 ì„ í˜¸í•œë‹¤: Hibernate ë°°í¬ë³¸ì— 있는 <literal>log4j.properties</literal>(ì´ê²ƒì€ ë””ë ‰í† ë¦¬ <literal>etc/</literal> ë‚´ì— ìžˆë‹¤)를 <literal>src</literal> ë””ë ‰í† ë¦¬ë¡œ ë³µì‚¬í•˜ê³ , 다ìŒìœ¼ë¡œ <literal>hibernate.cfg.xml</literal>ì„ ë³µì‚¬í•˜ë¼. ì˜ˆì œ êµ¬ì„±ì„ ì‚´íŽ´ë³´ê³ ë‹¹ì‹ ì´ ë” ë§Žì€ verbose ì¶œë ¥ì„ ì›í• ê²½ìš°ì— ì„¤ì •ë“¤ì„ ë³€ê²½í•˜ë¼. ë””í´íŠ¸ë¡œ Hibernate 시작 메시지는 stdout ìƒì— 보여진다."
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr "íŠœí† ë¦¬ì–¼ ì¸í”„ë¼ìŠ¤íŠ¸ëŸì²˜ëŠ” ì™„ì „í•˜ë‹¤ - ê·¸ë¦¬ê³ ìš°ë¦¬ëŠ” Hibernateë¡œ ì–´ë–¤ ì‹¤ì œ ìž‘ì—…ì„ í–‰í• ì¤€ë¹„ê°€ ë˜ì–´ 있다."
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr "ê°ì²´ 로딩과 ê°ì²´ ì €ìž¥"
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr "마지막으로 우리는 ê°ì²´ë“¤ì„ ë¡œë“œì‹œí‚¤ê³ ì €ìž¥í•˜ëŠ”ë° Hibernate를 ì‚¬ìš©í• ìˆ˜ 있다. 우리는 í•œ ê°œì˜ <literal>main()</literal> 메소드를 가진 í•œ ê°œì˜ <literal>EventManager</literal> í´ëž˜ìŠ¤ë¥¼ 작성한다:"
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr "우리는 í•œ ê°œì˜ ìƒˆë¡œìš´ <literal>Event</literal> ê°ì²´ë¥¼ ìƒì„±ì‹œí‚¤ê³ , ê·¸ê²ƒì„ Hibernateì—게 건네준다. Hibernate는 ì´ì œ SQLì„ ì²˜ë¦¬í•˜ê³ ë°ì´í„°ë² ì´ìŠ¤ ìƒì—ì„œ <literal>INSERT</literal>ë“¤ì„ ì‹¤í–‰ì‹œí‚¨ë‹¤. -우리가 ì´ê²ƒì„ 실행하기 ì „ì— ì½”ë“œë¥¼ 처리하는- <literal>Session</literal>ê³¼ <literal>Transaction</literal>ì„ ì‚´íŽ´ë³´ìž."
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr "<literal>Session</literal>ì€ í•œ ê°œì˜ ìž‘ì—… 단위ì´ë‹¤. 지금부터 우리는 ë‹¨ìˆ¨í•¨ì„ ìœ ì§€í• ê²ƒì´ê³ Hibernate <literal>Session</literal>ê³¼ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ 사ì´ì˜ ì¼-대-ì¼ ê³¼ë¦½í˜•(granularity)ì„ ê°€ì •í• ê²ƒì´ë‹¤. ì‹¤ì œ 기반 트랜ìžì…˜ 시스템으로부터 ìš°ë¦¬ì˜ ì†ŒìŠ¤ë¥¼ ì€í시키기 위해(ì´ ê²½ìš° 통ìƒì˜ JDBCì´ì§€ë§Œ, ê·¸ê²ƒì€ ë˜í•œ JTAì—ë„ ì‹¤í–‰ëœë‹¤) 우리는 Hibernate <literal>Session</literal> ìƒì—ì„œ ì´ìš© 가능한 <literal>Transaction</literal> API를 사용한다."
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr "<literal>sessionFactory.getCurrentSession()</literal>ì€ ë¬´ì—‡ì„ í–‰í•˜ëŠ”ê°€? ë¨¼ì € ë‹¹ì‹ ì€ ë‹¹ì‹ ì´ (<literal>HibernateUtil</literal> ë•ë¶„ì— ì‰½ê²Œ) <literal>SessionFactory</literal>ì„ ë‹¹ì‹ ì´ ì†Œìœ í•˜ê³ ìžˆë‹¤ë©´, ì›í•˜ëŠ” ë§Œí¼ ì–´ë””ì„œë“ ì—¬ëŸ¬ë²ˆ ê·¸ê²ƒì„ í˜¸ì¶œí• ìˆ˜ 있다. <literal>getCurrentSession()</literal> 메소드는 í•ìƒ \"현재ì˜\" ìž‘ì—… 단위를 반환한다. 우리가 <literal>hibernate.cfg.xml</literal> ë‚´ì—ì„œ ì´ ë§¤ì»¤ë‹ˆì¦˜ì— ëŒ€í•œ 구성 ì˜µì…˜ì„ \"thread\"ë¡œ ì „í™˜ì‹œì¼°ìŒì„ 기억하는가? 그러므로 ìž‘ì—…ì˜ í˜„ìž¬ 단위는 ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ 실행시키는 현재 ìžë°” ì“°ë ˆë“œì— ë¬¶ì—¬ 있다. 하지만 ì´ê²ƒì€ ì „ì²´ ê·¸ë¦¼ì´ ì•„ë‹ˆë©°, ë‹¹ì‹ ì€ ë˜í•œ scope(ì˜ì—), ìž‘ì—… 단위가 시작ë 때와 ìž‘ì—… 단위가 종료ë 때를 ê³ ë ¤í•´ì•¼ 한다."
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr "<literal>Session</literal>ì€ ê·¸ê²ƒì´ ì²˜ìŒìœ¼ë¡œ 필요로 ë˜ê³ <literal>getCurrentSession()</literal>ì— ëŒ€í•œ 첫 번째 í˜¸ì¶œì´ ì´ë£¨ì–´ì§ˆ ë•Œ 시작ëœë‹¤. 그때 ê·¸ê²ƒì€ Hibernateì— ì˜í•´ í˜„ìž¬ì˜ ì“°ë ˆë“œì— ë°”ì¸ë“œ ëœë‹¤. 커밋ë˜ë“ 롤백ë˜ë“ ê°„ì— íŠ¸ëžœìžì…˜ì´ 종료ë˜ê³ , Hibernateê°€ ìžë™ì 으로 ê·¸ ì“°ë ˆë“œë¡œë¶€í„° <literal>Session</literal>ì„ ë°”ì¸ë“œ í•´ì œì‹œí‚¤ê³ ë‹¹ì‹ ì„ ìœ„í•´ ì„¸ì…˜ì„ ë‹«ëŠ”ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ <literal>getCurrentSession()</literal>ì„ ë‹¤ì‹œ 호출한다면, ë‹¹ì‹ ì€ ìƒˆë¡œìš´ <literal>Session</literal>ì„ ì–»ê³ ìƒˆë¡œìš´ 작업단위를 ì‹œìž‘í• ìˆ˜ 있다. ì´ <emphasis>thread-bound</emphasis> í”„ë¡œê·¸ëž˜ë° ëª¨í˜•ì€ Hibernate를 사용하는 가장 대중ì ì¸ ë°©ë²•ì´ë‹¤. 왜ëƒí•˜ë©´ ê·¸ê²ƒì€ ë‹¹ì‹ ì˜ ì½”ë“œë¥¼ ìœ ì—°í•˜ê²Œ 계층화시키는 ê²ƒì„ í—ˆìš©í•´ì£¼ê¸° 때문ì´ë‹¤(트랜ìžì…˜ 경계 ë¶„í• ì½”ë“œëŠ” ë°ì´íŠ¸ ì ‘ê·¼ 코드와 구별지워질 수 있는ë°, ìš°ë!
¦¬ëŠ” ì´ íŠœí† ë¦¬ì–¼ì˜ ë’·ë¶€ë¶„ì—ì„œ ì´ê²ƒì„ 다룰 것ì´ë‹¤.)."
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr "ìž‘ì—… ì˜ì—ì˜ ë‹¨ìœ„ì™€ ê´€ë ¨í•˜ì—¬, Hibernate <literal>Session</literal>ì€ í•˜ë‚˜ ë˜ëŠ” 여러 ê°œì˜ ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ë“¤ì„ ì‹¤í–‰ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë 수 있는가? ìœ„ì˜ ì˜ˆì œëŠ” í•˜ë‚˜ì˜ ì˜¤í¼ë ˆì´ì…˜ì— í•œ ê°œì˜ <literal>Session</literal>ì„ ì‚¬ìš©í•˜ê³ ìžˆë‹¤. ì´ê²ƒì€ 순진한 ì¼ì¹˜ì´ë©°, ì˜ˆì œëŠ” ì–´ë–¤ 다른 ì ‘ê·¼ë²•ì„ ë³´ì—¬ì£¼ê¸°ì—는 충분히 복잡하지 않다. Hibernate <literal>Session</literal>ì˜ scope(ì˜ì—)ì€ ìœ ì—°í•˜ì§€ë§Œ ë‹¹ì‹ ì€ ê²°ì½” <emphasis>ëª¨ë“ </emphasis> ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ ê°ê°ì— 대해 새로운 Hibernate <literal>Session</literal>ì„ ì‚¬ìš©í•˜ë„ë¡ ë‹¹ì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ ì„¤ê³„í• ìˆ˜ 없다. ë”°ë¼ì„œ 심지어 ë‹¹ì‹ ì´ ë‹¤ìŒì˜ (매우 사소한) ì˜ˆì œë“¤ì—ì„œ 여러 번 ê·¸ê²ƒì„ ë³¼ 수 있ì„지ë¼ë„ <emphasis>session-per-operation</emphasis>ì„ í•˜ë‚˜ì˜ ì•ˆí‹°-패턴으로 간주하ë¼. ì‹¤ì œ (웹) 어플리케ì´ì…˜ì€ ì´ íŠœí† ë¦¬ì–¼ì˜ ë’!
·ë¶€ë¶„ì— ë³´ì—¬ì§„ë‹¤."
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr "트랜ìžì…˜ 핸들ë§ê³¼ ê²½ê³„êµ¬ë¶„ì— ëŒ€í•œ 추가 ì •ë³´ëŠ” <xref linkend=\"transactions\"/>ì„ ì‚´íŽ´ë³´ë¼. 우리는 ë˜í•œ ì•žì˜ ì˜ˆì œì—ì„œ ìž„ì˜ì˜ 오류 처리와 ë¡¤ë°±ì„ ìƒëžµí–ˆë‹¤."
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr "ì´ ì²« 번째 ë£¨í‹´ì„ ì‹¤í–‰í•˜ê¸° 위해서 우리는 호출 가능한 대ìƒì„ Ant 빌드 파ì¼ì— 추가해야 한다:"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr "<literal>action</literal> ì•„ê·œë¨¼íŠ¸ì˜ ê°’ì€ ëŒ€ìƒì„ í˜¸ì¶œí• ë•Œ ëª…ë ¹ ë¼ì¸ ìƒì—ì„œ ì„¤ì •ëœë‹¤:"
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr "컴파ì¼, êµ¬ì„±ì— ë”°ë¥¸ Hibernate 시작 후ì—, ë‹¹ì‹ ì€ ë§Žì€ ë¡œê·¸ ì¶œë ¥ì„ ë³´ê²Œ ë 것ì´ë‹¤. ëì—ì„œ ë‹¹ì‹ ì€ ë‹¤ìŒ ë¼ì¸ì„ ë°œê²¬í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr "ì´ê²ƒì€ Hibernateì— ì˜í•´ ì‹¤í–‰ëœ <literal>INSERT</literal>ì´ê³ , 물ìŒí‘œ 기호는 JDBC ë°”ì¸ë“œ 파ë¼ë¯¸í„°ë“¤ì„ 나타낸다. 아규먼트로서 ë°”ì¸ë“œ ëœ ê°’ë“¤ì„ ë³´ê±°ë‚˜ 장황한 로그를 줄ì´ë ¤ë©´ ë‹¹ì‹ ì˜ <literal>log4j.properties</literal>를 ì²´í¬í•˜ë¼."
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr "ì´ì œ 우리는 마찬가지로 ì €ìž¥ëœ ì´ë²¤íŠ¸ë“¤ì„ ì—´ê±°í•˜ê³ ìž ì›í•˜ë©°, 우리는 main ë©”ì†Œë“œì— í•œ ê°œì˜ ì˜µì…˜ì„ ì¶”ê°€í•œë‹¤:"
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr "우리는 ë˜í•œ 새로운 <literal>listEvents() method</literal> 메소드를 추가 시킨다:"
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr "여기서 우리가 í–‰í• ê²ƒì€ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° ëª¨ë“ ì¡´ìž¬í•˜ëŠ” <literal>Event</literal> ê°ì²´ë“¤ì„ 로드시키기 위해 HQL (Hibernate Query Language) 질ì˜ë¥¼ 사용하는 것ì´ë‹¤. Hibernate는 ì ì ˆí•œ SQLì„ ìƒì„±ì‹œí‚¬ 것ì´ê³ , ê·¸ê²ƒì„ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ì „ì†¡í•˜ê³ ë°ì´í„°ë¥¼ <literal>Event</literal> ê°ì²´ë“¤ì— 거주시킬 것ì´ë‹¤. ë‹¹ì‹ ì€ ë¬¼ë¡ HQL로서 보다 복잡한 질ì˜ë“¤ì„ ìƒì„±ì‹œí‚¬ 수 있다."
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr "ì´ì œ ì´ ëª¨ë“ ê²ƒì„ ì‹¤í–‰í•˜ê³ í…ŒìŠ¤íŠ¸í•˜ê¸° 위해, ë‹¤ìŒ ë‹¨ê³„ë“¤ì„ ë”°ë¥´ë¼:"
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr "ë°ì´í„°ë² ì´ìŠ¤ ì†ìœ¼ë¡œ ì–´ë–¤ ê²ƒì„ ì €ìž¥í•˜ê³ ë¬¼ë¡ ì•žì„œ hbm2ddlì„ í†µí•´ ë°ì´í„°ë² ì´ìŠ¤ 스키마를 산출시키기 위해 <literal>ant run -Daction=store</literal>를 실행하ë¼."
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr "ì´ì œ ë‹¹ì‹ ì˜ <literal>hibernate.cfg.xml</literal> íŒŒì¼ ì†ì—ì„œ ê·¸ 프로í¼í‹°ë¥¼ 주ì„ì²˜ë¦¬í•¨ìœ¼ë¡œì¨ hbm2ddlì„ ì‚¬ìš©ë¶ˆê°€ëŠ¥í•˜ê²Œ 하ë¼. 대개 ë‹¹ì‹ ì€ ì§€ì†ë˜ëŠ” 단위 테스팅ì—서는 ê·¸ê²ƒì„ ì‚¬ìš© 가능하게 ë‚´ë²„ë ¤ë‘ì–´ë„ ë˜ì§€ë§Œ, ë˜ ë‹¤ë¥¸ hbm2ddlì˜ ì‹¤í–‰ì€ ë‹¹ì‹ ì´ ì €ìž¥í–ˆë˜ ëª¨ë“ ê²ƒì„ <emphasis>drop</emphasis>시킬 것ì´ë‹¤ - <literal>create</literal> 구성 ì„¤ì •ì€ ì‹¤ì œë¡œ \"스키마로부터 ëª¨ë“ í…Œì´ë¸”ë“¤ì„ ë“œë¡ì‹œí‚¤ê³ 나서, SessionFactoryê°€ 빌드ë ë•Œ ëª¨ë“ í…Œì´ë¸”ë“¤ì„ ë‹¤ì‹œ ìƒì„±ì‹œí‚¤ëŠ” 것\"으로 변환ëœë‹¤."
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ì§€ê¸ˆ <literal>-Daction=list</literal>ë¡œ Ant를 í˜¸ì¶œí• ê²½ìš°, ë‹¹ì‹ ì€ ë‹¹ì‹ ì´ ì§€ê¸ˆê¹Œì§€ ì €ìž¥í–ˆë˜ ì´ë²¤íŠ¸ë“¤ì„ 보게 ë 것ì´ë‹¤. ë¬¼ë¡ ë‹¹ì‹ ì€ ë˜í•œ 여러 번 <literal>store</literal> ì•¡ì…˜ì„ í˜¸ì¶œí• ìˆ˜ 있다."
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr "노트 : ëŒ€ë¶€ë¶„ì˜ Hibernate 사용ìžë“¤ì€ ì´ ì§€ì ì—ì„œ ì‹¤íŒ¨í•˜ê³ ìš°ë¦¬ëŠ” ì •ê¸°ì 으로 <emphasis>Table not found</emphasis> 오류 ë©”ì‹œì§€ë“¤ì— ê´€í•œ ì§ˆë¬¸ì„ ë°›ëŠ”ë‹¤. 하지만 ë§Œì¼ ë‹¹ì‹ ì´ ìœ„ì— ì¡°ëª…ëœ ë‹¨ê²Œë“¤ì„ ë”°ë¥¼ 경우 ë‹¹ì‹ ì€ ì´ ë¬¸ì œë¥¼ 겪지 ì•Šì„ ê²ƒì´ê³ , hbm2ddlì´ ì²˜ìŒ ì‹¤í–‰ ì‹œì— ë°ì´í„°ë² ì´ìŠ¤ 스키마를 ìƒì„±ì‹œí‚¤ë¯€ë¡œ, ì°¨í›„ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ìž¬ì‹œìž‘ì€ ì´ ìŠ¤í‚¤ë§ˆë¥¼ ì‚¬ìš©í• ê²ƒì´ë‹¤. ë§Œì¼ ë‹¹ì‹ ì´ ë§¤í•‘ ê·¸ë¦¬ê³ /ë˜ëŠ” ë°ì´í„°ë² ì´ìŠ¤ 스키마를 ë³€ê²½í• ê²½ìš°ì—, ë‹¹ì‹ ì€ ë‹¤ì‹œ 한번 ë” hbm2ddlì„ ì´ìš© 가능하ë„ë¡ í•´ì•¼ 한다."
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr "파트 2 - ì—°ê´€ë“¤ì„ ë§¤í•‘í•˜ê¸°"
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr "우리는 í•œ ê°œì˜ ì˜ì† 엔티티 í´ëž˜ìŠ¤ë¥¼ í•œ ê°œì˜ í…Œì´ë¸”ë¡œ 매핑했다. ì´ê²ƒ 위ì—ì„œ ë¹Œë“œí•˜ê³ ëª‡ëª‡ í´ëž˜ìŠ¤ ì—°ê´€ë“¤ì„ ì¶”ê°€ì‹œí‚¤ìž. ë¨¼ì € 우리는 ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ì— ì‚¬ëžŒë“¤ì„ ì¶”ê°€í•˜ê³ ê·¸ë“¤ì´ ì°¸ì—¬í•˜ëŠ” ì´ë²¤íŠ¸ë“¤ì˜ 목ë¡ì„ ì €ìž¥í• ê²ƒì´ë‹¤."
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr "Person í´ëž˜ìŠ¤ 매핑하기"
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr "í´ëž˜ìŠ¤ì˜ 첫 번째 ìž¥ë©´ì€ ê°„ë‹¨í•˜ë‹¤:"
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr "<literal>Person.hbm.xml</literal>ë¡œ 명명ë˜ëŠ” 새로운 매핑 파ì¼ì„ ìƒì„±ì‹œì¼œë¼ (ë§¨ìœ„ì— DTD 참조를 잊지ë§ë¼):"
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr "마지막으로 새로운 ë§¤í•‘ì„ Hibernateì˜ êµ¬ì„±ì— ì¶”ê°€í•˜ë¼:"
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr "ì´ì œ 우리는 ì´ë“¤ ë‘ ê°œì˜ ì—”í‹°í‹°ë“¤ 사ì´ì— í•œ ê°œì˜ ì—°ê´€ì„ ìƒì„±ì‹œí‚¬ 것ì´ë‹¤. 명백하게, ê°œì¸ë“¤ì€ ì´ë²¤íŠ¸ë“¤ì— ì°¸ì—¬í• ìˆ˜ ìžˆê³ , ì´ë²¤íŠ¸ë“¤ì€ 참여ìžë“¤ì„ 갖는다. 우리가 다루어야 하는 설계 ì§ˆë¬¸ë“¤ì€ ë‹¤ìŒê³¼ 같다 : 방향성(directionality), 다중성(multiplicity), ê·¸ë¦¬ê³ ì½œë ‰ì…˜ 특징."
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr "단방향 Set-ê¸°ë°˜ì˜ ì—°ê´€"
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr "우리는 <literal>Person</literal> í´ëž˜ìŠ¤ì— ì´ë²¤íŠ¸ë“¤ì„ 가진 í•œ ê°œì˜ ì½œë ‰ì…˜ì„ ì¶”ê°€í• ê²ƒì´ë‹¤. ê·¸ 방법으로 우리는 명시ì ì¸ ì§ˆì˜-<literal>aPerson.getEvents()</literal>를 호출함으로ì¨-를 실행시키지 ì•Šê³ ì„œ íŠ¹ì • ê°œì¸ì— 대한 ì´ë²¤íŠ¸ë“¤ì„ 쉽게 네비게ì´íŠ¸í• 수 있다. 우리는 í•˜ë‚˜ì˜ Java ì½œë ‰ì…˜, í•˜ë‚˜ì˜ <literal>Set</literal>를 사용한다. 왜ëƒí•˜ë©´ ê·¸ ì½œë ‰ì…˜ì€ ì¤‘ë³µ ìš”ì†Œë“¤ì„ í¬í•¨í•˜ê¸° ì•Šì„ ê²ƒì´ê³ ê·¸ 순서가 우리와 ê´€ë ¨ë˜ì–´ 있지 않기 때문ì´ë‹¤."
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr "우리는 í•˜ë‚˜ì˜ <literal>Set</literal>으로 구현ëœ, í•˜ë‚˜ì˜ ë‹¨ë°©í–¥, 다중값 ì—°ê´€ë“¤ì„ í•„ìš”ë¡œ 한다. Java í´ëž˜ìŠ¤ë“¤ ë‚´ì— ì´ë¥¼ 위한 코드를 ìž‘ì„±í•˜ê³ ê·¸ëŸ° ë‹¤ìŒ ê·¸ê²ƒì„ ë§¤í•‘ì‹œí‚¤ìž:"
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr "우리가 ì´ ì—°ê´€ì„ ë§¤í•‘í•˜ê¸° ì „ì—, 다른 ì¸¡ì— ëŒ€í•´ ìƒê°í•˜ë¼. 명백하게 우리는 ì´ê²ƒì„ 단지 단방향으로 ìœ ì§€ì‹œí‚¬ 수 있다. ë˜ëŠ” 우리가 ê·¸ê²ƒì„ ì–‘ë°©í–¥ìœ¼ë¡œ 네비게ì´íŠ¸í•˜ëŠ” 것-예를 들어 <literal>anEvent.getParticipants()</literal>-ì´ ê°€ëŠ¥í•˜ë„ë¡ ì›í• 경우ì—, <literal>Event</literal>측 ìƒì— ë˜ ë‹¤ë¥¸ ì½œë ‰ì…˜ì„ ìƒì„±ì‹œí‚¬ 수 있다. ì´ê²ƒì€ ë‹¹ì‹ ì—게 남겨진 설계 ì„ íƒì´ì§€ë§Œ, ì´ ë…¼ì˜ì—ì„œ 명료한 ì ì€ ì—°ê´€ì˜ ë‹¤ì¤‘ì„±ì´ë‹¤: ì–‘ 측 ìƒì—ì„œ \"다중\" ê°’ì„ ê°–ëŠ” 경우, 우리는 ì´ê²ƒì„ <emphasis>many-to-many</emphasis> ì—°ê´€ì´ë¼ê³ 명명한다. 그러므로 우리는 Hibernateì˜ many-to-many ë§¤í•‘ì„ ì‚¬ìš©í•œë‹¤:"
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr "Hibernate는 ëª¨ë“ ì¢…ë¥˜ì˜ ì½œë ‰ì…˜ 매핑들, 가장 공통ì ì¸ <literal><set></literal>ì„ ì§€ì›í•œë‹¤. many-to-many ì—°ê´€ (ë˜ëŠ” <emphasis>n:m</emphasis> 엔티티 관계)ì˜ ê²½ìš°, í•œ ê°œì˜ ì—°ê´€ í…Œì´ë¸”ì´ í•„ìš”í•˜ë‹¤. ì´ í…Œì´ë¸” ë‚´ì— ìžˆëŠ” ê°ê°ì˜ í–‰ì€ í•œ ëª…ì˜ ê°œì¸ê³¼ í•œ ê°œì˜ ì´ë²¤íŠ¸ 사ì´ì˜ ë§í¬ë¥¼ 표현한다. í…Œì´ë¸” ì´ë¦„ì€ <literal>set</literal> ìš”ì†Œì˜ <literal>table</literal> ì†ì„±ìœ¼ë¡œ 구성ëœë‹¤. ì—°ê´€ ë‚´ì˜ ì‹ë³„ìž ì»¬ëŸ¼ ì´ë¦„ì€ ê°œì¸ ì¸¡ì— ëŒ€í•´ <literal><key></literal> 요소로 ì •ì˜ë˜ê³ ì´ë²¤íŠ¸ ì¸¡ì— ëŒ€í•œ 컬럼 ì´ë¦„ì€ <literal><many-to-many></literal>ì˜ <literal>column</literal> ì†ì„±ìœ¼ë¡œ ì •ì˜ëœë‹¤. ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì˜ ì½œë ‰ì…˜ ë‚´ì— ìžˆëŠ” ê°ì²´ë“¤ì˜ í´ëž˜ìŠ¤(ì •í™•í•˜ê²Œ : ì°¸ì¡°ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì˜ ë‹¤ë¥¸ 측 ìƒì— 있는 í´ëž˜ìŠ¤)를 Hibernateì—게 ì•Œë ¤ì£¼ì–´ì•¼ 한다."
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr "ë”°ë¼ì„œ ì´ ë§¤í•‘ì„ ìœ„í•œ ë°ì´í„°ë² ì´ìŠ¤ 스키마는 다ìŒê³¼ 같다:"
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr "ì—°ê´€ë“¤ì— ìž‘ì—…í•˜ê¸°"
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr "<literal>EventManager</literal> ì†ì— 있는 í•œ ê°œì˜ ìƒˆë¡œìš´ 메소드 ë‚´ì— ëª‡ëª‡ 사람들과 ì´ë²¤íŠ¸ë“¤ì„ 함께 ê°€ì ¸ì˜¤ìž:"
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr "<literal>Person</literal>ê³¼ <literal>Event</literal>를 로드시킨 후ì—, ì •ê·œ ì½œë ‰ì…˜ ë©”ì†Œë“œë“¤ì„ ì‚¬ìš©í•˜ì—¬ ì½œë ‰ì…˜ì„ ê°„ë‹¨í•˜ê²Œ 변경하ë¼. ë‹¹ì‹ ì´ ì•Œ 수 있듯ì´, <literal>update()</literal> ë˜ëŠ” <literal>save()</literal>ì— ëŒ€í•œ 명시ì ì¸ í˜¸ì¶œì´ ì¡´ìž¬í•˜ì§€ ì•Šê³ , 변경ë˜ì—ˆê³ ì €ìž¥í• í•„ìš”ê°€ 있는 ì½œë ‰ì…˜ì„ Hibernateê°€ ìžë™ì 으로 검출해낸다. ì´ê²ƒì€ <emphasis>ìžë™ì ì¸ dirty 체킹</emphasis>ì´ë¼ ë¶ˆë ¤ì§€ë©°, ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ì˜ ìž„ì˜ì˜ ê°ì²´ë“¤ì— 대한 name ë˜ëŠ” date 프로í¼í‹°ë¥¼ ë³€ê²½í•¨ìœ¼ë¡œì¨ ê·¸ê²ƒì„ ì‹œë„í• ìˆ˜ 있다. ê·¸ê²ƒë“¤ì´ <emphasis>ì˜ì†(persistent)</emphasis> ìƒíƒœì— 있는 ë™ì•ˆ, 즉 íŠ¹ì • Hibernate <literal>Session</literal>ì— ë°”ì¸ë“œë˜ì–´ 있는 ë™ì•ˆ(예를 들면. ê·¸ê²ƒë“¤ì€ ìž‘ì—… 단위 ì†ì— 방금 로드ë˜ì—ˆê±°ë‚˜ ì €ìž¥ë˜ì—ˆë‹¤), Hibernate는 ìž„ì˜ì˜ ë³€ê²½ë“¤ì„ ëª¨ë‹ˆí„°ë§í•˜ê³ 쓰기 ì´ë©´ì˜ 형태로 SQLì„ ì‹¤í–‰ì‹œí‚!
¨ë‹¤. 메모리 ìƒíƒœë¥¼ ë°ì´í„°ë² ì´ìŠ¤ì™€ ë™ê¸°í™” 시키는 ê³¼ì •ì€ ëŒ€ê°œ ì˜¤ì§ ìž‘ì—… ë‹¨ìœ„ì˜ ëì—ì„œì´ê³ , <emphasis>flushing</emphasis>ì´ë¼ 명명ëœë‹¤. ìš°ë¦¬ì˜ ì½”ë“œì—ì„œ, ìž‘ì—… 단위는 <literal>CurrentSessionContext</literal> í´ëž˜ìŠ¤ì— 대한 <literal>thread</literal> 구성 ì˜µì…˜ì— ì˜í•´ ì •ì˜ëœ 대로 - ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì˜ 커밋(ë˜ëŠ” 롤백)으로 ëì´ë‚œë‹¤."
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr "ë¬¼ë¡ ë‹¹ì‹ ì€ ë‹¤ë¥¸ ìž‘ì—… 단위 ì†ì— ê°œì¸ê³¼ ì´ë²¤íŠ¸ë¥¼ 로드시킬 수 ë„ ìžˆë‹¤. ë˜ëŠ” ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ê°ì²´ê·¸ ì˜ì† ìƒíƒœì— 있지 ì•Šì„ ë•Œ <literal>Session</literal>ì˜ ì™¸ë¶€ì—ì„œ ê°ì²´ë¥¼ 변경시킬 ìˆ˜ë„ ìžˆë‹¤(ë§Œì¼ ê°ì²´ê°€ ì´ì „ì— ì˜ì†í™” ë˜ì—ˆë‹¤ë©´, 우리는 ì´ ìƒíƒœë¥¼ <emphasis>detached</emphasis>ë¼ê³ 부른다). (매우 사실ì ì´ì§€ ì•Šì€) 코드 ë‚´ì—ì„œ ì´ê²ƒì€ 다ìŒê³¼ ê°™ì„ ìˆ˜ 있다:"
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr "<literal>update</literal>ì— ëŒ€í•œ í˜¸ì¶œì€ í•œ ê°œì˜ detached ê°ì²´ë¥¼ 다시 ì˜ì†í™” ì‹œí‚¤ê³ , ë‹¹ì‹ ì€ ê·¸ê²ƒì´ ìƒˆë¡œìš´ ìž‘ì—… ë‹¨ìœ„ì— ë°”ì¸ë“œëœë‹¤ê³ ë§í• 수 ìžˆê³ , ë”°ë¼ì„œ detached ë™ì•ˆì— ë‹¹ì‹ ì´ ê·¸ê²ƒì— ëŒ€í•´ 행한 ìž„ì˜ì˜ ë³€ê²½ë“¤ì´ ë°ì´í„°ë² ì´ìŠ¤ì— ì €ìž¥ë 수 있다. ì´ê²ƒì€ ë‹¹ì‹ ì´ ê·¸ 엔티티 ê°ì²´ì˜ ì½œë ‰ì…˜ì— ëŒ€í•´ í–‰í–ˆë˜ ìž„ì˜ì˜ 변경들(추가/ì‚ì œ)를 í¬í•¨í•œë‹¤."
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr "ë¬¼ë¡ , ìš°ë¦¬ì˜ í˜„ìž¬ ìƒí™©ì—ì„œ ì´ê²ƒì€ ë§Žì´ ì‚¬ìš©ë˜ì§€ 않지만, ê·¸ê²ƒì€ ë‹¹ì‹ ì´ ë‹¹ì‹ ìžì‹ ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ë¡œ ì„¤ê³„í• ìˆ˜ 있는 중요한 ê°œë…ì´ë‹¤. 지금 <literal>EventManager</literal>ì˜ main ë©”ì†Œë“œì— í•œ ê°œì˜ ìƒˆë¡œìš´ ì•¡ì…˜ì„ ì¶”ê°€í•˜ê³ ëª…ë ¹ ë¼ì¸ì—ì„œ ê·¸ê²ƒì„ í˜¸ì¶œí•˜ì—¬ ì´ ì—°ìŠµì„ ì™„ë£Œí•˜ë¼. ë§Œì¼ ë‹¹ì‹ ì´ í•œëª…ì˜ ê°œì¸ê³¼ í•œ ê°œì˜ ì´ë²¤íŠ¸ì— 대한 ì‹ë³„ìžë“¤ì„ 필요로 í• ê²½ìš° - <literal>save()</literal> 메소드가 ê·¸ê²ƒì„ ë°˜í™˜ì‹œí‚¨ë‹¤(ë‹¹ì‹ ì€ ê·¸ ì‹ë³„ìžë¥¼ 반환시키는 ì•žì˜ ë©”ì†Œë“œë“¤ 중 ëª‡ëª‡ì„ ë³€ê²½ì‹œì¼œì•¼ í• ê²ƒì´ë‹¤):"
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr "ì´ê²ƒì€ ë‘ ê°œì˜ ë™ë“±í•˜ê²Œ 중요한 í´ëž˜ìŠ¤ë“¤, ë‘ ê°œì˜ ì—”í‹°í‹°ë“¤ 사ì´ì—ì„œ í•œ ê°œì˜ ì—°ê´€ì— ê´€í•œ ì˜ˆì œì˜€ë‹¤. ì•žì„œ 언급했듯ì´, ì „í˜•ì ì¸ ëª¨í˜• ë‚´ì—는 다른 í´ëž˜ìŠ¤ë“¤ê³¼ 타ì´ë“¤ì´ 존재하는ë°, 대개 \"ëœ ì¤‘ìš”í•˜ë‹¤\". ë‹¹ì‹ ì€ ì´ë¯¸ <literal>int</literal> ë˜ëŠ” <literal>String</literal>ê³¼ ê°™ì€ ì–´ë–¤ ê²ƒì„ ì´ë¯¸ 보았다. 우리는 ì´ë“¤ í´ëž˜ìŠ¤ë“¤ì„ <emphasis>ê°’ 타입들(value types)</emphasis>ì´ë¼ ëª…ëª…í•˜ê³ , 그들 ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ íŠ¹ì • ì—”í‹°í‹°ì— <emphasis>ì˜ì¡´í•œë‹¤(depend)</emphasis>. ì´ë“¤ íƒ€ìž…ë“¤ì„ ê°€ì§„ ì¸ìŠ¤í„´ìŠ¤ë“¤ì€ 그것들 ìžì‹ ì˜ ì‹ë³„성(identity)를 갖지 않거나, ê·¸ê²ƒë“¤ì€ ì—”í‹°í‹°ë“¤ 사ì´ì—ì„œ ê³µìœ ë˜ì§€ë„ 않는다(ë‘ê°œì˜ personë“¤ì€ ì‹¬ì§€ì–´ ê·¸ê²ƒë“¤ì´ ê°™ì€ ì²« 번째 ì´ë¦„ì„ ê°–ëŠ” 경우ì—ë„ ë™ì¼í•œ <literal>firstname</literal>ì„ ì°¸ì¡°í•˜ì§€ 않는다 ). ë¬¼ë¡ ê°’ íƒ€ìž…ë“¤ì€ JDK ë‚´ì—ì„œ 발견ë ë¿ë§Œ 아니ë¼(사!
실, Hibernate 어플리케ì´ì…˜ì—ì„œ ëª¨ë“ JDK í´ëž˜ìŠ¤ë“¤ì€ ê°’ 타입들로 간주ëœë‹¤), ë‹¹ì‹ ì€ ë˜í•œ ë‹¹ì‹ ìŠ¤ìŠ¤ë¡œ ì¢…ì† í´ëž˜ìŠ¤ë“¤, 예를 들면 <literal>Address</literal> ë˜ëŠ” <literal>MonetaryAmount</literal>ì„ ìž‘ì„±í• ìˆ˜ 있다."
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr "ë‹¹ì‹ ì€ ë˜í•œ ê°’ íƒ€ìž…ë“¤ì„ ì„¤ê³„í• ìˆ˜ 있다. ì´ê²ƒì€ 다른 ì—”í‹°í‹°ë“¤ì— ëŒ€í•œ ì°¸ì¡°ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ê³¼ëŠ” ê°œë…ì 으로 매우 다르지만, Javaì—서는 대개 ë™ì¼í•œ 것으로 보여진다."
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr "ê°’ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜"
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr "우리는 ê°’ íƒ€ìž…ì˜ ê°ì²´ë“¤ì„ 가진 í•œ ê°œì˜ ì½œë ‰ì…˜ì„ <literal>Person</literal> ì—”í‹°í‹°ì— ì¶”ê°€ì‹œí‚¨ë‹¤. 우리는 email 주소를 ì €ìž¥í•˜ê³ ìž ì›í•˜ë¯€ë¡œ, 우리가 사용하는 íƒ€ìž…ì€ <literal>String</literal>ì´ê³ , ê·¸ ì½œë ‰ì…˜ì€ ë‹¤ì‹œ í•œ ê°œì˜ <literal>Set</literal>ì´ë‹¤:"
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr "ì´ <literal>Set</literal>ì— ëŒ€í•œ ë§¤í•‘ì€ ë‹¤ìŒê³¼ 같다:"
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr "ì•žì˜ ë§¤í•‘ê³¼ 비êµí•œ ì°¨ì´ì ì€ <literal>element</literal> 부분ì¸ë°, ê·¸ê²ƒì€ ê·¸ ì½œë ‰ì…˜ì´ ë˜ ë‹¤ë¥¸ ì—”í‹°í‹°ì— ëŒ€í•œ ì°¸ì¡°ë“¤ì„ í¬í•¨í•˜ì§€ ì•Šì„ ê²ƒì´ì§€ë§Œ <literal>String</literal>(ì†Œë¬¸ìž ì´ë¦„ì€ ê·¸ê²ƒì´ Hibernate 매핑 타입/변환ìžìž„ì„ ë‹¹ì‹ ì—게 ë§í•´ì¤€ë‹¤) íƒ€ìž…ì˜ ìš”ì†Œë“¤ì„ ê°€ì§„ í•œ ê°œì˜ ì½œë ‰ì…˜ì„ í¬í•¨í• ê²ƒìž„ì„ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤. ì¼ë‹¨ 다시 <literal>set</literal> ìš”ì†Œì˜ <literal>table</literal> ì†ì„±ì€ ê·¸ ì½œë ‰ì…˜ì— ëŒ€í•œ í…Œì´ë¸” ì´ë¦„ì„ ê²°ì •í•œë‹¤. <literal>key</literal> 요소는 ì½œë ‰ì…˜ í…Œì´ë¸” ë‚´ì—ì„œ foreign-key 컬럼 ì´ë¦„ì„ ì •ì˜í•œë‹¤. <literal>element</literal> 요소 ë‚´ì— ìžˆëŠ” <literal>column</literal> ì†ì„±ì€ <literal>String</literal> ê°’ë“¤ì´ ì‹¤ì œë¡œ ì €ìž¥ë 컬럼 ì´ë¦„ì„ ì •ì˜í•œë‹¤."
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr "ì—…ë°ì´íŠ¸ëœ 스키마를 살펴보ë¼:"
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr "ë‹¹ì‹ ì€ ì½œë ‰ì…˜ í…Œì´ë¸”ì˜ í”„ë¼ì´ë¨¸ë¦¬ 키가 ì‚¬ì‹¤ì€ ë‘ ì»¬ëŸ¼ë“¤ì„ ì‚¬ìš©í•˜ëŠ” í•œ ê°œì˜ í•©ì„± 키(composite key)ìž„ì„ ì•Œ 수 있다. ì´ê²ƒì€ ë˜í•œ ê°œì¸ì— 대해 email 주소가 중복ë 수 ì—†ìŒì„ ì˜ë¯¸í•˜ë©°, ê·¸ê²ƒì€ ì •í™•í•˜ê²Œ 우리가 Javaì—ì„œ setì„ í•„ìš”ë¡œ 하는 ì˜ë¯¸ë¡ ì´ë‹¤."
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr "마치 ê°œì¸ë“¤ê³¼ ì´ë²¤íŠ¸ë“¤ì„ ë§í¬ì‹œì¼œì„œ ì´ì „ì— ìš°ë¦¬ê°€ í–‰í–ˆë˜ ê²ƒì²˜ëŸ¼ ì´ì œ ë‹¹ì‹ ì€ ìš”ì†Œë“¤ì„ ì‹œë„í•˜ê³ ì´ ì½œë ‰ì…˜ì— ì¶”ê°€í• ìˆ˜ 있다. ê·¸ê²ƒì€ Javaì—ì„œ ë™ì¼í•œ 코드ì´ë‹¤."
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr "지금 우리는 ì½œë ‰ì…˜ì„ ì´ˆê¸°í™” ì‹œí‚¤ëŠ”ë° <emphasis>fetch</emphasis> 질ì˜ë¥¼ 사용하지 않았다. 그러므로 ì½œë ‰ì…˜ì˜ getter ë©”ì†Œë“œì— ëŒ€í•œ í˜¸ì¶œì€ ì½œë ‰ì…˜ì„ ì´ˆê¸°í™” 시키기 위해 추가ì ì¸ select를 트리거 시킬 것ì´ì–´ì„œ, 우리는 ê·¸ê²ƒì— ìš”ì†Œë¥¼ 추가시킬 수 있다. SQL 로그를 ê´€ì°°í•˜ê³ ì´ê²ƒì„ eager fetchë¡œ 최ì í™” ì‹œí‚¤ë ¤ê³ ì‹œë„하ë¼."
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr "Bi-directional associations"
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr "다ìŒìœ¼ë¡œ 우리는 ì–‘ë°©í–¥ ì—°ê´€ì„ ë§¤í•‘ì‹œí‚¬ ì˜ˆì •ì´ë‹¤-ê°œì¸ê³¼ ì´ë²¤íŠ¸ 사ì´ì— ì—°ê´€ì„ ë§Œë“œëŠ” ê²ƒì€ Javaì—ì„œ ì–‘ 측들ì—ì„œ ë™ìž‘한다. ë¬¼ë¡ ë°ì´í„°ë² ì´ìŠ¤ 스키마는 변경ë˜ì§€ ì•Šê³ , 우리는 ì—¬ì „ížˆ many-to-many ë‹¤ì¤‘ì„±ì„ ê°–ëŠ”ë‹¤. 관계형 ë°ì´í„°ë² ì´ìŠ¤ëŠ” ë„¤íŠ¸ì› í”„ë¡œê·¸ëž˜ë° ì–¸ì–´ 보다 훨씬 ë” ìœ ì—°í•˜ì—¬ì„œ, ê·¸ê²ƒì€ ë„¤ë¹„ê²Œì´ì…˜ 방향과 ê°™ì€ ì–´ë–¤ ê²ƒì„ í•„ìš”ë¡œ 하지 않는다 - ë°ì´í„°ëŠ” ì–´ë–¤ 가능한 바업ㅂ으로 보여질 수 ìžˆê³ ê²€ìƒ‰ë 수 있다."
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr "ë¨¼ì €, 참여ìžë“¤ì„ 가진 í•œ ê°œì˜ ì½œë ‰ì…˜ì„ <literal>Event</literal> Event í´ëž˜ìŠ¤ì— 추가시켜ë¼:"
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr "ì´ì œ <literal>Event.hbm.xml</literal> ë‚´ì— ì—°ê´€ì˜ ì´ ìª½ë„ ë§¤í•‘í•˜ë¼."
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr "ë‹¹ì‹ ì´ ë³¼ 수 있듯ì´, ì´ê²ƒë“¤ì€ ë‘ ë§¤í•‘ 문서들 ë‚´ì—ì„œ ì •ê·œ <literal>set</literal> 매핑들ì´ë‹¤. <literal>key</literal>와 <literal>many-to-many</literal>ì—ì„œ 컬럼 ì´ë¦„ë“¤ì€ ë‘ ë§¤í•‘ 문서들ì—ì„œ 바뀌어진다. 여기서 가장 중요한 ë¶€ê°€ë¬¼ì€ <literal>Event</literal>ì˜ ì½œë ‰ì…˜ ë§¤í•‘ì— ê´€í•œ <literal>set</literal> 요소 ë‚´ì— ìžˆëŠ” <literal>inverse=\"true\"</literal> ì†ì„±ì´ë‹¤."
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr "ì´ê²ƒì´ ì˜ë¯¸í•˜ëŠ” 바는 Hibernateê°€ 둘 사ì´ì˜ ë§í¬ì— 대한 ì •ë³´ë¥¼ ì•Œ 필요가 ìžˆì„ ë•Œ 다른 측-<literal>Person</literal> í´ëž˜ìŠ¤-를 ì·¨í• ê²ƒì´ë¼ëŠ” ì ì´ë‹¤. ì¼ë‹¨ ë‹¹ì‹ ì´ ìš°ë¦¬ì˜ ë‘ ì—”í‹°í‹°ë“¤ 사ì´ì— ì–‘ë°©í–¥ ë§í¬ê°€ ìƒì„±ë˜ëŠ” ë°©ë²•ì„ ì•ˆë‹¤ë©´ ì´ê²ƒì€ ì´í•´í•˜ê¸°ê°€ 훨씬 ë” ì‰¬ìš¸ 것ì´ë‹¤."
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr "ì–‘ë°©í–¥ ë§í¬ë“¤ì— 작업하기"
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr "첫 번째로 Hibernateê°€ ì •ê·œ Java ì˜ë¯¸ë¡ ì— ì˜í–¥ì„ 주지 ì•ŠìŒì„ ì—¼ë‘ì— ë‘ë¼. 우리는 단방향 ì˜ˆì œì—ì„œ <literal>Person</literal>ê³¼ <literal>Event</literal> 사ì´ì— 어떻게 í•œ ê°œì˜ ë§í¬ë¥¼ ìƒì„±ì‹œì¼°ëŠ”ê°€? 우리는 <literal>Event</literal> íƒ€ìž…ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ <literal>Person</literal> íƒ€ìž…ì˜ ì´ë²¤íŠ¸ ì°¸ì¡°ë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì— ì¶”ê°€ì‹œì¼°ë‹¤. ë”°ë¼ì„œ 명백하게 우리가 ì´ ë§í¬ë¥¼ 양방향으로 ë™ìž‘하ë„ë¡ ë§Œë“¤ê³ ìž ì›í•œë‹¤ë©´, 우리는 다른 측 ìƒì—ì„œ -í•˜ë‚˜ì˜ <literal>Person</literal> 참조를 í•˜ë‚˜ì˜ <literal>Event</literal> ë‚´ì— ìžˆëŠ” ì½œë ‰ì…˜ì— ì¶”ê°€ì‹œí‚´ìœ¼ë¡œì¨- ë™ì¼í•œ ê²ƒì„ í–‰í•´ì•¼ 한다. ì´ \"ì–‘ 측 ìƒì— ë§í¬ ì„¤ì •í•˜ê¸°\"는 ì ˆëŒ€ì 으로 필수ì ì´ê³ ë‹¹ì‹ ì€ ê·¸ê²ƒì„ í–‰í•˜ëŠ” ê²ƒì„ ê²°ì½” 잊지 ë§ì•„야 한다."
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr "ë§Žì€ ê°œë°œìžë“¤ì€ ë°©ë¹„ì±…ì„ í”„ë¡œê·¸ëž¨í•˜ê³ ì–‘ ì¸¡ë“¤ì„ ì •í™•í•˜ê²Œ ì„¤ì •í•˜ê¸° 위한 í•˜ë‚˜ì˜ ë§í¬ 관리 ë©”ì†Œë“œë“¤ì„ ìƒì„±ì‹œí‚¨ë‹¤. 예를 들면 <literal>Person</literal>ì—ì„œ :"
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr "ì½œë ‰ì…˜ì— ëŒ€í•œ get ë° set ë©”ì†Œë“œë“œì€ ì´ì œ protectedìž„ì„ ì¸ì§€í•˜ë¼ - ì´ê²ƒì€ ë™ì¼í•œ 패키지 ë‚´ì— ìžˆëŠ” í´ëž˜ìŠ¤ë“¤ê³¼ 서브í´ëž˜ìŠ¤ë“¤ì´ ê·¸ ë©”ì†Œë“œë“¤ì— ì ‘ê·¼í•˜ëŠ” ê²ƒì„ í—ˆìš©í•´ì£¼ì§€ë§Œ, ê·¸ ë°–ì˜ ëª¨ë“ ê²ƒë“¤ì´ ê·¸ ì½œë ‰ì…˜ë“¤ì„ (ë¬¼ë¡ , 대개) ì§ì ‘ 만지는 ê²ƒì„ ê¸ˆì§€ì‹œí‚¨ë‹¤. ë‹¹ì‹ ì€ ë‹¤ë¥¸ 측 ìƒì— 있는 ì½œë ‰ì…˜ì— ëŒ€í•´ ë™ì¼í•œ ê²ƒì„ í–‰í• ê²ƒì´ë‹¤."
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr "<literal>inverse</literal> 매핑 ì†ì„±ì€ 무엇ì¸ê°€? ë‹¹ì‹ ì˜ ê²½ìš°, ê·¸ë¦¬ê³ Javaì˜ ê²½ìš°, í•œ ê°œì˜ ì–‘ë°©í–¥ ë§í¬ëŠ” 단순히 ì–‘ ì¸¡ë“¤ì— ëŒ€í•œ ì°¸ì¡°ë“¤ì„ ì •í™•í•˜ê²Œ ì„¤ì •í•˜ëŠ” ë¬¸ì œì´ë‹¤. 하지만 Hibernate는 (ì»¨ìŠ¤íŠ¸ë ˆì¸íŠ¸ 위배를 피하기 위해서) SQL <literal>INSERT</literal> 문장과 <literal>UPDATE</literal> ë¬¸ìž¥ì„ ì •í™•í•˜ê²Œ ë§ˆë ¨í•˜ê¸°ì— ì¶©ë¶„í•œ ì •ë³´ë¥¼ ê°–ê³ ìžˆì§€ 않으며, ì–‘ë°©í–¥ ì—°ê´€ë“¤ì„ ì˜¬ë°”ë¥´ê²Œ 처리하기 위해 ì–´ë–¤ ë„ì›€ì„ í•„ìš”ë¡œ 한다. ì—°ê´€ì˜ í•œ ì¸¡ì„ <literal>inverse</literal>ë¡œ 만드는 ê²ƒì€ ê¸°ë³¸ì 으로 ê·¸ê²ƒì„ ë¬´ì‹œí•˜ê³ ê·¸ê²ƒì„ ë‹¤ë¥¸ ì¸¡ì˜ <emphasis>거울(mirror)</emphasis>ë¡œ 간주하ë„ë¡ Hibernateì—게 ì•Œë ¤ì¤€ë‹¤. ê·¸ê²ƒì€ Hibernateê°€ í•˜ë‚˜ì˜ ë°©í–¥ì„± 네비게ì´ì…˜ ëª¨í˜•ì„ í•œ ê°œì˜ SQL 스키마로 변환시킬 ë•Œ ëª¨ë“ ìŸì ë“¤ì„ ìž˜ í•´ê²°í•˜ëŠ”ë° í•„ìˆ˜ì ì¸ ëª¨ë“ ê²ƒì´ë‹¤. ë‹¹ì‹ ì´ ì—¼ë‘ì— ë‘어야 하는 규칙들ì!
€ 간단하다 : ëª¨ë“ ì–‘ë°©í–¥ ì—°ê´€ë“¤ì€ í•œ ìª½ì´ <literal>inverse</literal>ì¼ í•„ìš”ê°€ 있다. one-to-many ì—°ê´€ì—ì„œ ê·¸ê²ƒì€ many-측ì´ì–´ì•¼ í•˜ê³ , many-to-many ì—°ê´€ì—ì„œ ë‹¹ì‹ ì€ ì–´ëŠ ì¸¡ì´ë“ ì„ íƒí• 수 있으며 ì°¨ì´ì ì€ ì—†ë‹¤."
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr "Let's turn this into a small web application."
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr "파트 3 - EventManager 웹 어플리케ì´ì…˜"
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr "Hibernate 웹 어플리케ì´ì…˜ì€ ëŒ€ë¶€ë¶„ì˜ ìŠ¤íƒ ë“œì–¼ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ê³¼ ê°™ì´ <literal>Session</literal>ê³¼ <literal>Transaction</literal>ì„ ì‚¬ìš©í•œë‹¤. 하지만 몇몇 공통 íŒ¨í„´ë“¤ì´ ìœ ìš©í•˜ë‹¤. 우리는 ì´ì œ <literal>EventManagerServlet</literal>를 작성한다. ì´ ì„œë¸”ë¦¿ì€ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ì €ìž¥ëœ ëª¨ë“ ì´ë²¤íŠ¸ë“¤ì„ ë‚˜ì—´í• ìˆ˜ ìžˆê³ , ê·¸ê²ƒì€ ìƒˆë¡œìš´ ì´ë²¤íŠ¸ë“¤ì„ ìž…ë ¥í•˜ê¸° 위한 HTML formì„ ì œê³µí•œë‹¤."
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr "기본 서블릿 작성하기"
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr "ë‹¤ìŒ ìž¥ì—ì„œ 우리는 Hibernate를 Tomcat ë° WebWork와 통합시킨다. <literal>EventManager</literal>는 ìš°ë¦¬ì˜ ì„±ìž¥í•˜ëŠ” 어플리케ì´ì…˜ì„ ë”ì´ìƒ ê°ë‹¹í•˜ì§€ 못한다. ë‹¹ì‹ ì˜ ì†ŒìŠ¤ ë””ë ‰í† ë¦¬ì—ì„œ <literal>events</literal> 패키지 ë‚´ì— ìƒˆë¡œìš´ í´ëž˜ìŠ¤ë¥¼ ìƒì„±ì‹œì¼œë¼:"
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr "ì„œë¸”ë¦¿ì€ HTTP <literal>GET</literal> ìš”ì²ë“¤ ë§Œì„ ì²˜ë¦¬í•˜ë¯€ë¡œ, 우리가 구현하는 메소드는 <literal>doGet()</literal>ì´ë‹¤:"
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr "우리가 여기서 ì 용하는 íŒ¨í„´ì€ <emphasis>session-per-request</emphasis>ì´ë‹¤. í•˜ë‚˜ì˜ ìš”ì²ì´ ì„œë¸”ë¦¿ì— ë„ë‹¬í• ë•Œ, í•˜ë‚˜ì˜ ìƒˆë¡œìš´ Hibernate <literal>Session</literal>ì´ <literal>SessionFactory</literal> ìƒì˜ <literal>getCurrentSession()</literal>ì— ëŒ€í•œ 첫번째 í˜¸ì¶œì„ í†µí•´ 열린다. 그때 í•˜ë‚˜ì˜ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì´ 시작ë˜ê³ , ëª¨ë“ ë°ì´í„° ì ‘ê·¼ì´ í•˜ë‚˜ì˜ íŠ¸ëžœìžì…˜ ë‚´ì—ì„œ ë°œìƒí•˜ëŠ” í•œ, ë°ì´í„°ê°€ ì½í˜€ì§€ê±°ë‚˜ 기ë¡ë˜ëŠ”ë° ë¬¸ì œê°€ 없다(우리는 어플리케ì´ì…˜ë“¤ ë‚´ì—ì„œ auto-commit 모드를 사용하지 않는다)."
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr "ëª¨ë“ ë°ì´í„°ë² ì´ìŠ¤ 오í¼ë ˆì´ì…˜ ê°ê°ì— 대해 새로운 Hibernate <literal>Session</literal>ì„ ì‚¬ìš©í•˜ì§€ <emphasis>ë§ë¼</emphasis>. ì „ì²´ ìš”ì²ì— 대해 ì˜ì—지워진 í•œ ê°œì˜ Hibernate <literal>Session</literal>ì„ ì‚¬ìš©í•˜ë¼. ê·¸ê²ƒì´ ìžë™ì 으로 í˜„ìž¬ì˜ ìžë°” ì“°ë ˆë“œì— ë°”ì¸ë“œë˜ë„ë¡ <literal>getCurrentSession()</literal>ì„ ì‚¬ìš©í•˜ë¼."
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr "다ìŒìœ¼ë¡œ, ìš”ì²ì˜ 가능한 ì•¡ì…˜ë“¤ì´ ì²˜ë¦¬ë˜ê³ ì‘답 HTMLì´ ë Œë”ë§ëœë‹¤. 우리는 곧장 그부분으로 ê°ˆ 것ì´ë‹¤."
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr "마지막으로, 프로세싱과 ë Œë”ë§ì´ 완료ë ë•Œ ìž‘ì—… 단위가 종료ëœë‹¤. ë§Œì¼ ì–´ë–¤ ë¬¸ì œê°€ 프로세싱과 ë Œë”ë§ ë™ì•ˆì— ë°œìƒë 경우, í•˜ë‚˜ì˜ ì˜ˆì™¸ìƒí™©ì´ ë˜ì ¸ì§ˆ 것ì´ê³ ë°ì´í„°ë² ì´ìŠ¤ 트랜ìžì…˜ì€ 롤백ë 것ì´ë‹¤. ì´ê²ƒì€ <literal>session-per-request</literal>ì„ ì™„ë£Œì‹œí‚¨ë‹¤. ëª¨ë“ ì„œë¸”ë¦¿ ë‚´ì— ìžˆëŠ” 트랜ìžì…˜ êµ¬íš ì½”ë“œ ëŒ€ì‹ ì— ë‹¹ì‹ ì€ ë˜í•œ 서블릿 필터를 ì‚¬ìš©í• ìˆ˜ 있다. <emphasis>Open Session in View</emphasis>ë¡œ 명명ë˜ëŠ” ì´ íŒ¨í„´ì— ëŒ€í•œ 추가 ì •ë³´ëŠ” Hibernate 웹 사ì´íŠ¸ì™€ 위키를 ë³´ë¼. ë‹¹ì‹ ì€ ì„œë¸”ë¦¿ ë‚´ì—서가 ì•„ë‹Œ JSP ë‚´ì— ë‹¹ì‹ ì˜ ë·°ë¥¼ ë Œë”ë§í•˜ëŠ” ê²ƒì„ ê³ ë ¤í• ë•Œ ê·¸ê²ƒì„ í•„ìš”ë¡œ í• ê²ƒì´ë‹¤."
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr "프로세싱과 ë Œë”ë§"
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr "ìš”ì²ì˜ 처리와 페ì´ì§€ì˜ ë Œë”ë§ì„ 구현하ìž."
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr "Java와 HTMLì´ í˜¼í•©ëœ ì´ ì½”ë”©ì´ ë³´ë‹¤ 복잡한 어플리케ì´ì…˜ì—ì„œ ê¸°ì¤€ì´ ë 수 없다 í• ì§€ë¼ë„, 우리는 단지 ì´ íŠœí† ë¦¬ì–¼ ë‚´ì—ì„œ 기본 Hibernate ê°œë…ë“¤ì„ ì„¤ëª…í•˜ê³ ìžˆìŒì„ ì—¼ë‘ì— ë‘ë¼. 코드는 í•˜ë‚˜ì˜ HTML í—¤ë”와 í•˜ë‚˜ì˜ footer를 프린트한다. ì´ íŽ˜ì´ì§€ ë‚´ì— ì´ë²¤íŠ¸ 엔트리를 위한 í•˜ë‚˜ì˜ HTML formê³¼ ë°ì´í„°ë² ì´ìŠ¤ ë‚´ì— ìžˆëŠ” ëª¨ë“ ì´ë²¤íŠ¸ë“¤ì˜ 목ë¡ì´ 프린트ëœë‹¤. 첫 번째 메소드는 시행ì ì´ê³ ì˜¤ì§ HTMLì„ ì¶œë ¥í•œë‹¤:"
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr "<literal>listEvents()</literal> 메소드는 í•˜ë‚˜ì˜ ì§ˆì˜ë¥¼ 실행하기 위해서 í˜„ìž¬ì˜ ì“°ë ˆë“œì— ê²°í•©ëœ Hibernate <literal>Session</literal>ì„ ì‚¬ìš©í•œë‹¤:"
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr "마지막으로, <literal>store</literal> ì•¡ì…˜ì€ <literal>createAndStoreEvent()</literal> 메소드로 디스패치ëœë‹¤. ê·¸ê²ƒì€ í˜„ìž¬ ì“°ë ˆë“œì˜ <literal>Session</literal>ì„ ì‚¬ìš©í•œë‹¤:"
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr "즉 ì„œë¸”ë¦¿ì´ ì™„ì„±ëœë‹¤. ì„œë¸”ë¦¿ì— ëŒ€í•œ ìš”ì²ì€ í•˜ë‚˜ì˜ ë‹¨ì¼ <literal>Session</literal>ê³¼ <literal>Transaction</literal> ë‚´ì—ì„œ 처리ë 것ì´ë‹¤. ì´ì „처럼 ìŠ¤íƒ ë“œì–¼ë¡ ì–´í”Œë¦¬ì¼€ì´ì…˜ì—ì„œ, Hibernate는 ì´ë“¤ ê°ì²´ë“¤ì„ 실행 ì¤‘ì¸ í˜„ìž¬ ì“°ë ˆë“œì— ìžë™ì 으로 ë°”ì¸ë“œì‹œí‚¬ 수 있다. ì´ê²ƒì€ ë‹¹ì‹ ì˜ ì½”ë“œë¥¼ 계층화 ì‹œí‚¤ê³ ë‹¹ì‹ ì´ ì¢‹ì•„í•˜ëŠ” ìž„ì˜ì˜ 방법으로 <literal>SessionFactory</literal>ì— ì ‘ê·¼í•˜ëŠ” ìžìœ 를 ë‹¹ì‹ ì—게 부여한다. 대개 ë‹¹ì‹ ì€ ë³´ë‹¤ ì„¸ë ¨ëœ ì„¤ê³„ë¥¼ ì‚¬ìš©í• ê²ƒì´ê³ ë°ì´í„° ì ‘ê·¼ 코드를 ë°ì´í„° ì ‘ê·¼ ê°ì²´ë“¤ ë‚´ë¡œ ì´ë™ì‹œí‚¬ 것ì´ë‹¤(DAO 패턴). 추가 ì˜ˆì œë“¤ì€ Hibernate 위키를 ë³´ë¼."
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr "배치하기 ê·¸ë¦¬ê³ í…ŒìŠ¤íŠ¸í•˜ê¸°"
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr "ì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ 배치하기 위해서 ë‹¹ì‹ ì€ í•˜ë‚˜ì˜ ì›¹ ì•„ì¹´ì´ë¸Œ, WAR를 ìƒì„±ì‹œì¼œì•¼ 한다. ë‹¤ìŒ Ant targetì„ ë‹¹ì‹ ì˜ <literal>build.xml</literal> ë‚´ì— ì¶”ê°€í•˜ë¼:"
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr "ì´ targetì€ ë‹¹ì‹ ì˜ í”„ë¡œì 트 ë””ë ‰í† ë¦¬ ë‚´ì— <literal>hibernate-tutorial.war</literal>ë¡œ ëª…ëª…ëœ í•˜ë‚˜ì˜ íŒŒì¼ì„ ìƒì„±ì‹œí‚¨ë‹¤. ê·¸ê²ƒì€ ë‹¹ì‹ ì˜ í”„ë¡œì íŠ¸ì˜ ê¸°ë³¸ ë””ë ‰í† ë¦¬ ë‚´ì— ê¸°ëŒ€ë˜ëŠ” ëª¨ë“ ë¼ì´ë¸ŒëŸ¬ë¦¬ë“¤ê³¼ <literal>web.xml</literal> 디스í¬ë¦½í„°ë¥¼ 패키징한다:"
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr "ë‹¹ì‹ ì´ ì›¹ 어플리케ì´ì…˜ì„ 컴파ì¼í•˜ê³ 배치하기 ì „ì—, í•˜ë‚˜ì˜ ë¶€ê°€ì ì¸ ë¼ì´ë¸ŒëŸ¬ë¦¬ê°€ í•„ìš”í•¨ì„ ë…¸íŠ¸í•˜ë¼: <literal>jsdk.jar</literal>. ë‹¹ì‹ ì´ ì´ë¯¸ ì´ ë¼ì´ë¸ŒëŸ¬ë¦¬ë¥¼ ê°–ê³ ìžˆì§€ ì•Šì„ ê²½ìš°, ì´ê²ƒì€ Java servlet development kitì´ë©°, Sun 웹 사ì´íŠ¸ë¡œë¶€í„° ê·¸ê²ƒì„ ì–»ì–´ì„œ ê·¸ê²ƒì„ ë‹¹ì‹ ì˜ ë¼ì´ë¸ŒëŸ¬ë¦¬ ë””ë ‰í† ë¦¬ì— ë³µì‚¬í•˜ë¼. 하지만 ê·¸ê²ƒì€ ì˜¤ì§ ì»´íŒŒì¼ ì‹œì—만 사용ë 것ì´ê³ WAR 패키지ì—서는 ì œì™¸ëœë‹¤."
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr "ë¹Œë“œí•˜ê³ ë°°ì¹˜í•˜ê¸° 위해 ë‹¹ì‹ ì˜ í”„ë¡œì 트 ë””ë ‰í† ë¦¬ ë‚´ì—ì„œ <literal>ant war</literal>를 í˜¸ì¶œí•˜ê³ <literal>hibernate-tutorial.war</literal> 파ì¼ì„ ë‹¹ì‹ ì˜ Tomcat <literal>webapp</literal> ë””ë ‰í† ë¦¬ë¡œ 복사하ë¼. ë§Œì¼ ë‹¹ì‹ ì´ Tomcatì„ ì„¤ì¹˜í•˜ì§€ 않았다면, ê·¸ê²ƒì„ ë‚´ë ¤ë°›ì•„ 설치 ì§€ì¹¨ë“¤ì„ ë”°ë¥´ë¼. ë‹¹ì‹ ì€ ì´ ì–´í”Œë¦¬ì¼€ì´ì…˜ì„ 배치하기 위해 ìž„ì˜ì˜ Tomcat êµ¬ì„±ì„ ë³€ê²½í•˜ì§€ 않아야 한다."
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr "ì¼ë‹¨ ë°°ì¹˜í–ˆê³ Tomcatì´ ì‹¤í–‰ì¤‘ì´ë©´, <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>ë¡œ 어플리케ì´ì…˜ì— ì ‘ê·¼í•˜ë¼. 첫 번째 ìš”ì²ì´ ë‹¹ì‹ ì˜ ì„œë¸”ë¦¿ì— ë„ë‹¬í• ë•Œ Hibernateê°€ 초기화(<literal>HibernateUtil</literal> ë‚´ì— ìžˆëŠ” static initializerê°€ 호출ëœë‹¤) ë˜ëŠ” ê²ƒì„ ë³´ê¸° 위해 ê·¸ë¦¬ê³ ë§Œì¼ ì–´ë–¤ 예외ìƒí™©ë“¤ì´ ë°œìƒí• 경우 ìƒì„¸í•œ ì¶œë ¥ì„ ì–»ê¸° 위해서 Tomcat 로그를 지켜보ë„ë¡ í•˜ë¼."
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr "<title>요약</title>"
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr "ì´ íŠœí† ë¦¬ì–¼ì€ ê°„ë‹¨í•œ ìŠ¤íƒ ë“œì–¼ë¡ Hibernate 어플리케ì´ì…˜ê³¼ í•˜ë‚˜ì˜ ìž‘ì€ ì›¹ 어플리케ì´ì…˜ì„ 작성하는 기초를 다루었다."
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ ì´ë¯¸ Hibernateì— ìžì‹ ì´ ìžˆë‹¤ê³ ëŠë‚€ë‹¤ë©´, ë‹¹ì‹ ì´ í¥ë¯¸ë¥¼ 찾는 ì£¼ì œë“¤ì— ëŒ€í•œ 참조 문서 목차를 ê³„ì† ë¸Œë¼ìš°ì§•í•˜ë¼ - 가장 ë§Žì´ ìš”ì²ë˜ëŠ” ê²ƒì€ íŠ¸ëžœìžì…˜ 처리(<xref linkend=\"transactions\"/>), 페치 í¼í¬ë¨¼ìŠ¤(<xref linkend=\"performance\"/>), ë˜ëŠ” API 사용법(<xref linkend=\"objectstate\"/>), ê·¸ë¦¬ê³ ì§ˆì˜ íŠ¹ì§•ë“¤(<xref linkend=\"objectstate-querying\"/>)ì´ë‹¤."
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr "ë” ë§Žì€(특화ëœ) íŠœí† ë¦¬ì–¼ë“¤ì— ëŒ€í•´ì„œëŠ” Hibernate 웹 사ì´íŠ¸ë¥¼ ì²´í¬í•˜ëŠ” ê²ƒì„ ìžŠì§€ ë§ë¼."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,420 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr "XML 매핑"
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr "ì´ê²ƒì€ Hibernate3.0ì—ì„œ 실험ì ì¸ íŠ¹ì§•ì´ê³ 매우 활ë™ì 으로 개발 ì¤‘ì— ìžˆìŒì„ 노트하ë¼."
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr "XML ë°ì´í„°ë¡œ 작업하기"
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr "Hibernate는 ë‹¹ì‹ ì´ ì˜ì† POJO들로 작업하는 것과 아주 ë™ì¼í•œ 방법으로 ì˜ì† XML ë°ì´í„°ì— 작업하ë„ë¡ í•´ì¤€ë‹¤. íŒŒì‹±ëœ XML 트리는 단지 ê°ì²´ ë ˆë²¨ì—ì„œ 관계형 ë°ì´í„°ë¥¼ 나타내는 ë˜ ë‹¤ë¥¸ 방법으로 간주ë 수 있다. í•˜ë‚˜ì˜ íŒŒì‹±ëœ XML 트리는 POJO들 ëŒ€ì‹ , ê°ì²´ ë ˆë²¨ì—ì„œ 관계형 ë°ì´í„°ë¥¼ 표현하는 단지 ë˜ ë‹¤ë¥¸ 방법으로 간주ë 수 있다."
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr "Hibernate는 XML íŠ¸ë¦¬ë“¤ì„ ì²˜ë¦¬í•˜ëŠ” API로서 dom4j를 지ì›í•œë‹¤. ë‹¹ì‹ ì€ ë°ì´í„°ë² ì´ìŠ¤ë¡œë¶€í„° dom4j íŠ¸ë¦¬ë“¤ì„ ê²€ìƒ‰í•˜ê³ ë‹¹ì‹ ì´ ê·¸ 트리를 ë°ì´í„°ë² ì´ìŠ¤ì™€ ìžë™ì 으로 ë™ê¸°í™”시키기 위해 ì–´ë–¤ ë³€ê²½ì„ í–‰í•˜ë„ë¡ í•˜ëŠ” 질ì˜ë“¤ì„ ìž‘ì„±í• ìˆ˜ 있다. ë‹¹ì‹ ì€ ì‹¬ì§€ì–´ XML 문서를 ì·¨í•˜ê³ , dom4j를 사용하여 ê·¸ê²ƒì„ íŒŒì‹±í•˜ê³ , Hibernateì˜ ë‹¤ìŒ ê¸°ë³¸ì ì¸ ì˜¤í¼ë ˆì´ì…˜ë“¤ 중 ì–´ë–¤ 것으로서 ê·¸ê²ƒì„ ë°ì´í„°ë² ì´ìŠ¤ì— ì €ìž¥ì‹œí‚¬ 수 있다: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal>(merging(병합)ì€ ì•„ì§ ì§€ì›ë˜ì§€ 않는다)."
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr "ì´ íŠ¹ì§•ì€ ë°ì´í„° ê°€ì ¸ì˜¤ê¸°/내보내기,JMS ë˜ëŠ” SOAP ê·¸ë¦¬ê³ XSLT-ê¸°ë°˜ì˜ ë ˆí¬íŒ…ì„ í†µí•œ 엔티티 ë°ì´í„°ì˜ 구체화를 í¬í•¨í•˜ëŠ” ë§Žì€ ì–´í”Œë¦¬ì¼€ì´ì…˜ë“¤ì„ 갖는다."
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr "í•˜ë‚˜ì˜ ë§¤í•‘ì€ í´ëž˜ìŠ¤ë“¤ì˜ 프로í¼í‹°ë“¤ê³¼ XML ë¬¸ì„œì˜ ë…¸ë“œë“¤ì„ ë°ì´í„°ë² ì´ìŠ¤ë¡œ ë™ì‹œì— ë§¤í•‘ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë 수 있거나, ë§Œì¼ ë§¤í•‘í• í´ëž˜ìŠ¤ê°€ 존재하지 ì•Šì„ ê²½ìš°, ê·¸ê²ƒì€ ë‹¨ì§€ XMLì„ ë§¤í•‘ì‹œí‚¤ëŠ”ë° ì‚¬ìš©ë ìˆ˜ë„ ìžˆë‹¤."
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr "XMLê³¼ í´ëž˜ìŠ¤ ë§¤í•‘ì„ í•¨ê»˜ ì§€ì •í•˜ê¸°"
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr "다ìŒì€ POJO와 XMLì„ ë™ì‹œì— 매핑시키는 ì˜ˆì œì´ë‹¤ :"
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr "XML ë§¤í•‘ë§Œì„ ì§€ì •í•˜ê¸°"
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr "다ìŒì€ POJO í´ëž˜ìŠ¤ê°€ 존재하지 않는 ì˜ˆì œì´ë‹¤:"
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr "ì´ ë§¤í•‘ì€ dom4j 트리로서 ë˜ëŠ” 프로í¼í‹° name/value ìŒë“¤(java <literal>Map</literal>들)ì˜ ê·¸ëž˜í”„ë¡œì„œ ë°ì´í„°ì— ì ‘ê·¼í•˜ëŠ” ê²ƒì„ ë‹¹ì‹ ì—게 허용해준다. 프로í¼í‹° ì´ë¦„ë“¤ì€ HQL 질ì˜ë“¤ ë‚´ì—ì„œ 참조ë ìˆ˜ë„ ìžˆëŠ” 순수하게 논리ì ì¸ êµ¬ì¡°ì²´ë“¤ì´ë‹¤."
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr "XML 매핑 메타ë°ì´í„°"
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr "ë§Žì€ Hibernate 매핑 ìš”ì†Œë“¤ì€ <literal>node</literal> ì†ì„±ì„ 수용한다. ì´ê²ƒì€ ë‹¹ì‹ ì´ í”„ë¡œí¼í‹° ë˜ëŠ” 엔티티 ë°ì´í„°ë¥¼ ì†Œìœ í•˜ëŠ” XML ì†ì„±ì´ë‚˜ ìš”ì†Œì˜ ì´ë¦„ì„ ì§€ì •í•˜ë„ë¡ í•œë‹¤. <literal>node</literal> ì†ì„±ì˜ í¬ë§·ì€ ë‹¤ìŒ ì¤‘ 하나ì´ì–´ì•¼ 한다:"
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr "<literal>\"element-name\"</literal> - ëª…ëª…ëœ XML 요소로 매핑시킨다"
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr "<literal>\"@attribute-name\"</literal> - ëª…ëª…ëœ XML ì†ì„±ìœ¼ë¡œ 매핑시킨다"
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr "<literal>\".\"</literal> - 부모 요소로 매핑 시킨다"
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr "<literal>\"element-name/@attribute-name\"</literal> - ëª…ëª…ëœ ìš”ì†Œì˜ ëª…ëª…ëœ ì†ì„±ìœ¼ë¡œ 매핑시킨다"
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr "ì½œë ‰ì…˜ë“¤ê³¼ ë‹¨ì¼ ê°’ ì½œë ‰ì…˜ë“¤ì˜ ê²½ìš°, 추가ì ì¸ <literal>embed-xml</literal> ì†ì„±ì´ 존재한다. ë§Œì¼ <literal>embed-xml=\"true\"</literal> ì¼ ê²½ìš°, ì—°ê´€ëœ ì—”í‹°í‹°(ë˜ëŠ” value íƒ€ìž…ì„ ê°€ì§„ ì½œë ‰ì…˜)ì— ëŒ€í•œ ë””í´íŠ¸ XML 트리는 ê·¸ ì—°ê´€ì„ ì†Œìœ í•˜ëŠ” ì—”í‹°í‹°ì— ëŒ€í•œ XML 트리 ì†ì— ì§ì ‘ 삽입ë 것ì´ë‹¤. ê·¸ ë°–ì˜ ê²½ìš° <literal>embed-xml=\"false\"</literal> ì¼ ê²½ìš°, ì°¸ì¡°ëœ ì‹ë³„ìž ê°’ ë§Œì´ ë‹¨ì¼ í¬ì¸íŠ¸ ì—°ê´€ë“¤ì— ëŒ€í•´ ë‚˜íƒ€ë‚ ê²ƒì´ê³ ì½œë ‰ì…˜ë“¤ì€ ë‹¨ìˆœížˆ ì „í˜€ 나타나지 ì•Šì„ ê²ƒì´ë‹¤."
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr "ë‹¹ì‹ ì€ ë„ˆë¬´ ë§Žì€ ì—°ê´€ë“¤ì— ëŒ€í•´ <literal>embed-xml=\"true\"</literal>ë¡œ 남겨ë‘지 ë§ë„ë¡ ì£¼ì˜í•´ì•¼ 한다. 왜ëƒí•˜ë©´ XMLì´ ìˆœí™˜ì 으로 잘 처리하지 못하기 때문ì´ë‹¤!"
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr "ì´ ê²½ìš°ì—, 우리는 ì‹¤ì œ account ë°ì´í„°ê°€ ì•„ë‹Œ, account idë“¤ì„ ê°€ì§„ ì½œë ‰ì…˜ì„ ì‚½ìž…ì‹œí‚¤ê¸°ë¡œ ê²°ì •í–ˆë‹¤. ë‹¤ìŒ HQL 질ì˜:"
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr "는 다ìŒê³¼ ê°™ì€ ë°ì´í„°ì…‹ë“¤ì„ ë°˜í™˜í• ê²ƒì´ë‹¤:"
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr "ë§Œì¼ ë‹¹ì‹ ì´ <literal><one-to-many></literal> ë§¤í•‘ì— ëŒ€í•´ <literal>embed-xml=\"true\"</literal>를 ì„¤ì •í• ê²½ìš°, ë°ì´í„°ëŠ” 다ìŒê³¼ ê°™ì´ ë³´ì¼ ìˆ˜ë„ ìžˆë‹¤:"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr "XML ë°ì´í„° 처리하기"
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr "ìš°ë¦¬ì˜ ì–´í”Œë¦¬ì¼€ì´ì…˜ ë‚´ì—ì„œ XML ë¬¸ì„œë“¤ì„ ë‹¤ì‹œ ì½ì–´ë“¤ì´ê³ ì—…ë°ì´íŠ¸ 시키ìž. 우리는 dom4j ì„¸ì…˜ì„ ì–»ì–´ì„œ ì´ê²ƒì„ 행한다:"
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.getRootElement().add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr "XML ê¸°ë°˜ì˜ ë°ì´í„° ê°€ì ¸ì˜¤ê¸°/내보내기를 êµ¬í˜„í•˜ëŠ”ë° ì´ íŠ¹ì§•ê³¼ Hibernateì˜ <literal>replicate()</literal> 오í¼ë ˆì´ì…˜ì„ 결합시키는 ê²ƒì´ ë§¤ìš° ìœ ìš©í•˜ë‹¤."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/ko-KR/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/ko-KR/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/ko-KR/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - Relational Persistence for Idiomatic Java"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "Documentação da Referência do Hibernate"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr "Arquitetura"
+
+#: index.docbook:24
+msgid "Overview"
+msgstr "Visão Geral"
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr "Uma visão bem ampla da arquitetura do Hibernate:"
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr "Esse diagrama mostra o Hibernate usando o banco de dados e a configuração de dados para prover persistência de serviços (e persistência de objetos) para o aplicativo."
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 "Nós gostarÃamos de mostrar uma visão mais detalhada da arquitetura em execução. Infelizmente, o Hibernate é muito flexÃvel e suporta várias aproximações. Nós iremos mostrar os dois extremos. Na arquitetura mais simples o aplicativo fornece suas próprias conexões JDBC e gerencia suas transações. Esta abordagem usa o mÃnimo de subconjuntos das APIs do Hibernate:"
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr "A arquitetura \"completa\" abstrai a aplicação de ter de lidar diretamente com JDBC/JTA e APIs e deixa o Hibernate tomar conta dos detalhes."
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr "Algumas definições dos objetos do diagrama:"
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr "Um cache threadsafe (imutáveis) composto de identidades compiladas para um único banco de dados. Uma fabrica para <literal>Session</literal> e um cliente de <literal>ConnectionProvider</literal>. Pode conter um cachê opcional de dados (segundo nÃvel) reutilizáveis entre transações, no nÃvel de processo- ou cluster."
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr "Session (<literal>org.hibernate.Session</literal>)"
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr "Objeto single-threaded, de vida curta, representando uma conversação entre o aplicativo e o armazenamento persistente. Cria uma camada sobre uma conexão JDBC. É uma fabrica de <literal>Transaction</literal>. Possui um cachê obrigatório (primeiro nÃvel) de objetos persistentes, usado para navegação no gráficos de objetos e pesquisa de objetos pelo identificador."
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr "Objetos persistentes e coleções"
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr "Objetos, de vida curta, single threaded contendo estado persistente e função de negócios. Esses podem ser JavaBeans/POJOs, onde única coisa especial sobre eles é que são associados a (exatamente uma) <literal>Session</literal>. Quando a <literal>Session</literal> é fechada, eles são separados e liberados para serem usados dentro de qualquer camada da aplicacao (Ex. diretamente como data transfer objects de e para a camada de apresentação)"
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr "Objetos e coleções desatachados e transientes"
+
+#: index.docbook:119
+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 "Instâncias de classes persistentes que ainda não estão associadas a uma <literal>Session</literal>. Eles podem ter sido instanciados pela aplicação e não persistido (ainda) ou eles foram instanciados por uma <literal>Session</literal> que foi encerrada."
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr "Transaction (<literal>org.hibernate.Transaction</literal>)"
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 "(Opcional) Objeto de vida curta, single threaded, usado pela aplicação para especificar unidades atômicas de trabalho. Abstrai o aplicativo de lidar diretamente com transações JDBC, JTA ou CORBA. Uma <literal>Session</literal> pode, em alguns casos, iniciar várias <literal>Transaction</literal>s. Entretanto, a demarcação da transação, mesmo utilizando API ou Transaction subjacentes, nunca é opcional!"
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr "(Opcional) Uma fábrica de (e combinações de) conexões JDBC. Abstrai a aplicação de lidar diretamente com <literal>Datasource</literal> ou <literal>DriverManager</literal>. Não exposto para a aplicação, mas pode ser implementado ou estendido pelo programador."
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr "(Opcional) Uma fábrica para instâncias de <literal>Transaction</literal>. Não exposta a aplicação, mas pode ser extendida/implementada pelo programador."
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr "Extension Interfaces"
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "O Hibernate oferece várias opções de interfaces estendidas que você pode implementar para customizar sua camada persistente. Veja a documentação da API para maiores detalhes."
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr "Dada uma arquitetura simples, o aplicativo passa pelas APIs <literal>Transaction</literal>/<literal>TransactionFactory</literal> e/ou <literal>ConnectionProvider</literal> para se comunicar diretamente com a transação JTA ou JDBC."
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr "Estados de instância"
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr "Uma instância de classes persistentes pode estar em um dos três diferentes estados, que são definidos respeitando um <emphasis>contexto persistente</emphasis>. O objeto <literal>Session</literal> do Hibernate é o contexto persistente:"
+
+#: index.docbook:188
+msgid "transient"
+msgstr "transiente"
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr "A instância não é, e nunca foi associada com nenhum contexto persistente. Não possui uma identidade persistente (valor de chave primária)."
+
+#: index.docbook:198
+msgid "persistent"
+msgstr "persistente"
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr "A instância está atualmente associada a um contexto persistente. Possui uma identidade persistente (valor de chave primária) e, talvez, correspondente a um registro no banco de dados. Para um contexto persistente em particular, o Hibernate <emphasis>guarantees</emphasis> que a identidade persistente é equivalente a identidade Java (na localização em memória do objeto)."
+
+#: index.docbook:212
+msgid "detached"
+msgstr "desatachado"
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr "A instância foi associada com um contexto persistente, porém este contexto foi fechado, ou a instância foi serializada por outro processo. Possui uma identidade persistente, e, talvez, correspondenta a um registro no banco de dados. Para instâncias desatachadas, o Hibernate não garante o relacionamento entre identidade persistente e identidade Java."
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr "Integração JMX"
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX é padrão J2EE para manipulação de componentes Java. O Hibernate pode ser manipulado por um serviço JMX padrão. Nós fornecemos uma implementação do MBean na distribuição, <literal>org.hibernate.jmx.HibernateService</literal>."
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr "Para um exemplo de como instalar o Hibernate como um serviço JMX em um servidor de aplicativo JBoss, por favor, consulte o manual do usuário do JBoss. No JBoss As, você poderá ver os benefÃcios de de se fazer o deploy usando JMX:"
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>Session Management:</emphasis> O ciclo de vida de uma <literal>Session</literal> do Hibernate pode ser automaticamente conectada a um escopo de transação JTA. Isso significa que você não precisará mais abrir e fechar manualmente uma <literal>Session</literal>, isso se torna trabalho para um interceptor EJB do JBoss . Você também não precisa se preocupar, nunca mais, com demarcação de transação em seu código (a não ser que você prefira escrever uma camada persistente portável, para isso, use a API opcional do Hibernate <literal>Transaction</literal>). Você deve chamar <literal>HibernateContext</literal> para acessar uma <literal>Session</literal>."
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>HAR deployment:</emphasis>: Normalmente você faz o deploy de um serviço JMX do Hibernate usando um serviço descritor de deploy do JBoss (em um EAR e/ou arquivo SAR), que suporta todas as configurações usuais de uma <literal>SessionFactory</literal> do Hibernate. Entretanto, você ainda precisa nomear todos os seus arquivos de mapeamento no descritor de deploração. Se você decidir usar o deploy opcional HAR, o JBoss irá automaticamente detectar todos os seus arquivos de mapeamento no seu arquivo HAR."
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr "Consulte o manual do usuário do JBoss AS, para obter maiores informações sobre essas opções."
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>. Outra opção disponÃvel como um serviço JMX são as estatÃsticas de execução do Hibernate. Veja a <xref linkend=\"configuration-optional-statistics\"/>."
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr "Suporte JCA"
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental. O Hibernate pode também ser configurado como um conector JCA. Por favor, visite o website para maiores detalhes. Entretanto, note que o suporte JCA do Hibernate ainda é considerado experimental."
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr "Sessões contextuais"
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 "Muitas aplicações que usam o Hibernate necessita de algum tipo de sessão \"contextual\", onde uma sessão dada é na verdade um escopo de um contexto. Entretanto, através de aplicações a definição sobre um contexto é geralmente diferente; e contextos diferentes definem escopos diferentes. Aplicações usando versões anteriores ao Hibernate 3.0 tendem a utilizar tanto sessões contextuais baseadas em <literal>ThreadLocal</literal>, classes utilitárias como <literal>HibernateUtil</literal>, ou utilizar frameworks de terceiros(como Spring ou Pico) que provê sessões contextuais baseadas em proxy."
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr "A partir da versão 3.0.1, o Hibernate adicionou o método <literal>SessionFactory.getCurrentSession()</literal>. Inicialmente, este assume o uso de transações <literal>JTA</literal>, onde a transação <literal>JTA</literal> define tanto o escopo quanto o contexto de uma sessão atual. O time do Hibernate mantém este recurso, desenvolvendo as diversas implementações do <literal>JTA TransactionManager</literal>, a maioria (se não todos) aplicativos deveria utilizar o gerenciador de transações <literal>JTA</literal> sendo ou não instalados dentro de um container <literal>J2EE</literal>. Baseado neste recurso, você deveria sempre utilizar sessões contextuais baseadas em <literal>JTA</literal>."
+
+#: index.docbook:307
+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 "Entretanto, na versão 3.1, o processo por trás do método <literal>SessionFactory.getCurrentSession()</literal> é agora plugavel. Com isso, uma nova interface (<literal>org.hibernate.context.CurrentSessionContext</literal>) e um novo parâmetro de configuração (<literal>hibernate.current_session_context_class</literal>) foram adicionados para possibilitar a compatibilidade do contexto e do escopo na definição de sessões correntes."
+
+#: index.docbook:314
+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 "De uma olhada em Javadocs sobre a interface <literal>org.hibernate.context.CurrentSessionContext</literal> para uma discussão detalhada. Ela define um método único, <literal>currentSession()</literal>, com o qual a implementação é responsável por rastrear a sessão contextual corrente. Por fora do \"encapsulamento\", o Hibernate possui duas implementações dessa interface."
+
+#: index.docbook:324
+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> - As sessões correntes são rastreadas e recebem um escopo por uma transação <literal>JTA</literal>. O processamento aqui é exatamente igual ao antigo processo JTA. Consulte em Javadocs para maiores detalhes."
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - As sessões correntes são rastreadas por uma thread de execução. Novamente, consulte em Javadocs para maiores detalhes."
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr "<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 never open, flush, or close a <literal>Session</literal>."
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr "As duas primeiras implementações usam o modelo de programação \"uma sessão – uma transação do banco de dados\", também conhecida e usado como <emphasis>sessão por requisição</emphasis>. O começo e o fim de uma sessão Hibernate é definida pela duração da transação do banco de dados. Se você usa demarcação programática de transação (por exemplo. em J2SE puro ou com JTA /UserTransaction/BMT), você é recomendado a usar a API Hibernate <literal>Transaction</literal> para esconder a base do sistema de transação do seu código. Se você executa em um container EJB que suporta CMT, os limites das transações são definidas declarativamente e você não necessita de qualquer transação ou operação de demarcação de sessão no seu código. Consulte o <xref linkend=\"transactions\"/> para mais informações exemplos de código."
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 "O parâmetro de configuração <literal>hibernate.current_session_context_class</literal> define que a implementação <literal>org.hibernate.context.CurrentSessionContext</literal> deve ser usada. Note que para compatibilidade anterior, se este parâmetro de configuração não é determinado mas um <literal>org.hibernate.transaction.TransactionManagerLookup</literal> é configurado, Hibernate usará o <literal>org.hibernate.context.JTASessionContext</literal>. Tipicamente, o valor deste parâmetro nomearia apenas a classe de implementação para usar; para as duas implementações out-of-the-box, entretanto, há três pequenos nomes correspondentes, \"jta\", \"thread\", and \"managed\"."
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,608 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr ""
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr ""
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr ""
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr ""
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr ""
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr ""
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr ""
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr ""
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr ""
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr ""
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr ""
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr ""
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr ""
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr ""
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr ""
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr ""
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr ""
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr ""
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr ""
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr ""
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr ""
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr ""
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr ""
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr ""
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr ""
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr ""
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr ""
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr ""
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr ""
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr ""
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,2459 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr ""
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr ""
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr ""
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr ""
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr ""
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr ""
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr ""
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr ""
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr ""
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr ""
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr ""
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr ""
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr ""
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr ""
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr ""
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr ""
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr ""
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr ""
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr ""
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr ""
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr ""
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr ""
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr ""
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr ""
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr ""
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr ""
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr ""
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr ""
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr ""
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr ""
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr ""
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr ""
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr ""
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr ""
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr ""
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr ""
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr ""
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr ""
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr ""
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr ""
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr ""
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr ""
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr ""
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr ""
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr ""
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr ""
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr ""
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr ""
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr ""
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr ""
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr ""
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr ""
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr ""
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr ""
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr ""
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr ""
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr ""
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr ""
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr ""
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr ""
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr ""
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr ""
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr ""
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr ""
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr ""
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr ""
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr ""
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr ""
+
+#: index.docbook:532
+msgid "Generator"
+msgstr ""
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr ""
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr ""
+
+#: index.docbook:551
+msgid "increment"
+msgstr ""
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr ""
+
+#: index.docbook:562
+msgid "identity"
+msgstr ""
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr ""
+
+#: index.docbook:572
+msgid "sequence"
+msgstr ""
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr ""
+
+#: index.docbook:582
+msgid "hilo"
+msgstr ""
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr ""
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr ""
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr ""
+
+#: index.docbook:604
+msgid "uuid"
+msgstr ""
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr ""
+
+#: index.docbook:614
+msgid "guid"
+msgstr ""
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr ""
+
+#: index.docbook:622
+msgid "native"
+msgstr ""
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr ""
+
+#: index.docbook:632
+msgid "assigned"
+msgstr ""
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr ""
+
+#: index.docbook:642
+msgid "select"
+msgstr ""
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr ""
+
+#: index.docbook:651
+msgid "foreign"
+msgstr ""
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr ""
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr ""
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr ""
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr ""
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr ""
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr ""
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr ""
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr ""
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr ""
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr ""
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr ""
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr ""
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr ""
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr ""
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr ""
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr ""
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr ""
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr ""
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr ""
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr ""
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr ""
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr ""
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr ""
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr ""
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr ""
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr ""
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr ""
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr ""
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr ""
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr ""
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr ""
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr ""
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr ""
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr ""
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr ""
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr ""
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr ""
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr ""
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr ""
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr ""
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr ""
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr ""
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr ""
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr ""
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr ""
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr ""
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr ""
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr ""
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr ""
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr ""
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr ""
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr ""
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr ""
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr ""
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr ""
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr ""
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr ""
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr ""
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr ""
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr ""
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr ""
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr ""
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr ""
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr ""
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr ""
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr ""
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr ""
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr ""
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr ""
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr ""
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr ""
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr ""
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr ""
+
+#: index.docbook:1284
+msgid "property"
+msgstr ""
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr ""
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr ""
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr ""
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr ""
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr ""
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr ""
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr ""
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr ""
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr ""
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr ""
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr ""
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr ""
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr ""
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr ""
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr ""
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr ""
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr ""
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr ""
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr ""
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr ""
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr ""
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr ""
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr ""
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr ""
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr ""
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr ""
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr ""
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr ""
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr ""
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr ""
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr ""
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr ""
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr ""
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr ""
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr ""
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr ""
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr ""
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr ""
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr ""
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr ""
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr ""
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr ""
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr ""
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr ""
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr ""
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr ""
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr ""
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr ""
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr ""
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr ""
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr ""
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr ""
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr ""
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr ""
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr ""
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr ""
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr ""
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr ""
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr ""
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr ""
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr ""
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr ""
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr ""
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr ""
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr ""
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr ""
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr ""
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr ""
+
+#: index.docbook:1928
+msgid "properties"
+msgstr ""
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr ""
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr ""
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr ""
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr ""
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr ""
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr ""
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr ""
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr ""
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr ""
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr ""
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr ""
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr ""
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr ""
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr ""
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr ""
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr ""
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr ""
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr ""
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr ""
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr ""
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr ""
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr ""
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr ""
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr ""
+
+#: index.docbook:2179
+msgid "join"
+msgstr ""
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr ""
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr ""
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr ""
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr ""
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr ""
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr ""
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr ""
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr ""
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr ""
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr ""
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr ""
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr ""
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr ""
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr ""
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr ""
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr ""
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr ""
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr ""
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr ""
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr ""
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr ""
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:2367
+msgid "import"
+msgstr ""
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr ""
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr ""
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr ""
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr ""
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr ""
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr ""
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr ""
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr ""
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr ""
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr ""
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr ""
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr ""
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr ""
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr ""
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr ""
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr ""
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr ""
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr ""
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr ""
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr ""
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr ""
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr ""
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr ""
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr ""
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr ""
+
+#: index.docbook:2567
+msgid "string"
+msgstr ""
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr ""
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr ""
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr ""
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr ""
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr ""
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr ""
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr ""
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr ""
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr ""
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr ""
+
+#: index.docbook:2630
+msgid "binary"
+msgstr ""
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr ""
+
+#: index.docbook:2638
+msgid "text"
+msgstr ""
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr ""
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr ""
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr ""
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr ""
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr ""
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr ""
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr ""
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr ""
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr ""
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr ""
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr ""
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr ""
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr ""
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr ""
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr ""
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr ""
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr ""
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr ""
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr ""
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr ""
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr ""
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr ""
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr ""
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr ""
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr ""
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,281 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr ""
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr ""
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr ""
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr ""
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr ""
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr ""
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr ""
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr ""
+
+#: index.docbook:41
+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 ""
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr ""
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr ""
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr ""
+
+#: index.docbook:62
+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 ""
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr ""
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr ""
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:91
+msgid "Note that 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 ""
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr ""
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr ""
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr ""
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr ""
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr ""
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 ""
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr ""
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr ""
+
+#: index.docbook:156
+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 ""
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 ""
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr ""
+
+#: index.docbook:181
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr ""
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr ""
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr ""
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 ""
+
+#: index.docbook:220
+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. Note however that this might 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 ""
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ""
+
+#: index.docbook:247
+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 ""
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr ""
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr ""
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr ""
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr ""
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr ""
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr ""
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr ""
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr ""
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr ""
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr ""
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr ""
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr ""
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr ""
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr ""
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr ""
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr ""
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr ""
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr ""
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr ""
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr ""
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr ""
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr ""
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr ""
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr ""
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr ""
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr ""
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr ""
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr ""
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr ""
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr ""
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr ""
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr ""
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr ""
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr ""
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr ""
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr ""
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr ""
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr ""
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,919 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr ""
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr ""
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr ""
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr ""
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr ""
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr ""
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr ""
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr ""
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr ""
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr ""
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr ""
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr ""
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr ""
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr ""
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr ""
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr ""
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr ""
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr ""
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr ""
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr ""
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr ""
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr ""
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr ""
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr ""
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr ""
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr ""
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr ""
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr ""
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr ""
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr ""
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr ""
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr ""
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr ""
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr ""
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr ""
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr ""
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr ""
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr ""
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr ""
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr ""
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr ""
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr ""
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr ""
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr ""
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr ""
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr ""
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr ""
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr ""
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr ""
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr ""
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr ""
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr ""
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr ""
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr ""
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr ""
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr ""
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr ""
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr ""
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr ""
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr ""
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr ""
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr ""
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr ""
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr ""
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr ""
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr ""
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr ""
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr ""
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr ""
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr ""
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr ""
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr ""
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr ""
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr ""
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr ""
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr ""
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr ""
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr ""
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr ""
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr ""
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr ""
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr ""
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr ""
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr ""
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr ""
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr ""
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr ""
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr ""
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr ""
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr ""
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr ""
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr ""
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr ""
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr ""
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr ""
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr ""
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr ""
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr ""
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr ""
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr ""
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr ""
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,372 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr ""
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr ""
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr ""
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr ""
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr ""
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr ""
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:38
+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 ""
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr ""
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr ""
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr ""
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr ""
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr ""
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr ""
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr ""
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 ""
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr ""
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr ""
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr ""
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr ""
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr ""
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr ""
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr ""
+
+#: index.docbook:170
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr ""
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr ""
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr ""
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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 ""
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr ""
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr ""
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr ""
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr ""
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr ""
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr ""
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr ""
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr ""
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1489 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr ""
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr ""
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr ""
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr ""
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr ""
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr ""
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr ""
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr ""
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr ""
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr ""
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr ""
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr ""
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr ""
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr ""
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr ""
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr ""
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr ""
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr ""
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr ""
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr ""
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr ""
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr ""
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr ""
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr ""
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr ""
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr ""
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr ""
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr ""
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr ""
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr ""
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr ""
+
+#: index.docbook:179
+msgid "database user"
+msgstr ""
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: index.docbook:187
+msgid "database user password"
+msgstr ""
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr ""
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr ""
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr ""
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr ""
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr ""
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr ""
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr ""
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr ""
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr ""
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr ""
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr ""
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr ""
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr ""
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr ""
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr ""
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr ""
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr ""
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr ""
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr ""
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr ""
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr ""
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr ""
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr ""
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr ""
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr ""
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr ""
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr ""
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr ""
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr ""
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr ""
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr ""
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr ""
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr ""
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr ""
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr ""
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr ""
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr ""
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr ""
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr ""
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr ""
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr ""
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr ""
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr ""
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr ""
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr ""
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr ""
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr ""
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr ""
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr ""
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr ""
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr ""
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr ""
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr ""
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr ""
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr ""
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr ""
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr ""
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr ""
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr ""
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr ""
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr ""
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr ""
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr ""
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr ""
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr ""
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr ""
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr ""
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr ""
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr ""
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr ""
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr ""
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr ""
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr ""
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr ""
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr ""
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr ""
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr ""
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr ""
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr ""
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr ""
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr ""
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr ""
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr ""
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr ""
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr ""
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr ""
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr ""
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr ""
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr ""
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr ""
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr ""
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr ""
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr ""
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr ""
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr ""
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr ""
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr ""
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr ""
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr ""
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr ""
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr ""
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr ""
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr ""
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr ""
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr ""
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr ""
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr ""
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr ""
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr ""
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr ""
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr ""
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr ""
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr ""
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr ""
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr ""
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr ""
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr ""
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr ""
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr ""
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr ""
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr ""
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr ""
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr ""
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr ""
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr ""
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr ""
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr ""
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr ""
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr ""
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr ""
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr ""
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr ""
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr ""
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr ""
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr ""
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr ""
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr ""
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr ""
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr ""
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr ""
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr ""
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr ""
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr ""
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr ""
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr ""
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr ""
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr ""
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr ""
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr ""
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr ""
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr ""
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr ""
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr ""
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr ""
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr ""
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr ""
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr ""
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr ""
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr ""
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr ""
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr ""
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr ""
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr ""
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr ""
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr ""
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr ""
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr ""
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr ""
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr ""
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr ""
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr ""
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr ""
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr ""
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr ""
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr ""
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr ""
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr ""
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr ""
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr ""
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr ""
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr ""
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr ""
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr ""
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr ""
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr ""
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr ""
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr ""
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr ""
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr ""
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr ""
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr ""
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr ""
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr ""
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr ""
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr ""
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr ""
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr ""
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr ""
+
+#: index.docbook:1219
+msgid "Category"
+msgstr ""
+
+#: index.docbook:1220
+msgid "Function"
+msgstr ""
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr ""
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr ""
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr ""
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr ""
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr ""
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr ""
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr ""
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr ""
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr ""
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr ""
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr ""
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr ""
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr ""
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr ""
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr ""
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr ""
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr ""
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr ""
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr ""
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr ""
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr ""
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr ""
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr ""
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr ""
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr ""
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr ""
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr ""
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr ""
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr ""
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr ""
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr ""
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr ""
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr ""
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr ""
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr ""
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr ""
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr ""
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr ""
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr ""
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr ""
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr ""
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr ""
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr ""
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr ""
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr ""
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr ""
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr ""
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr ""
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr ""
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr ""
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr ""
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr ""
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr ""
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr ""
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr ""
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr ""
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr ""
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr ""
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr ""
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr ""
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr ""
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr ""
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr ""
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr ""
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr ""
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr ""
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr ""
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr ""
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr ""
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr ""
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr ""
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr ""
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr ""
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr ""
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr ""
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr ""
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,245 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr ""
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr ""
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr ""
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr ""
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr ""
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr ""
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr ""
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr ""
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Event system"
+msgstr ""
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr ""
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr ""
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr ""
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr ""
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr ""
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr ""
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr ""
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr ""
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr ""
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr ""
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr ""
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr ""
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr ""
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr ""
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,653 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr ""
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr ""
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr ""
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr ""
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr ""
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr ""
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr ""
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr ""
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr ""
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr ""
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr ""
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr ""
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr ""
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr ""
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr ""
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr ""
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,287 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr ""
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr ""
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr ""
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr ""
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr ""
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr ""
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr ""
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr ""
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr ""
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr ""
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr ""
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr ""
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr ""
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr ""
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr ""
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr ""
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr ""
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr ""
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr ""
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr ""
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr ""
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr ""
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr ""
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr ""
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr ""
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr ""
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr ""
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr ""
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr ""
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr ""
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr ""
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr ""
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr ""
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr ""
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr ""
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,450 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr ""
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr ""
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr ""
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr ""
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr ""
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr ""
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr ""
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,149 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr ""
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr ""
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr ""
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr ""
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr ""
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr ""
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr ""
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr ""
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr ""
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr ""
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr ""
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,477 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr ""
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr ""
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr ""
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr ""
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr ""
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr ""
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr ""
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr ""
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr ""
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr ""
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr ""
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr ""
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr ""
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:102
+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 ""
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr ""
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr ""
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:127
+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 ""
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr ""
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr ""
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr ""
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr ""
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr ""
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr ""
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr ""
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr ""
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr ""
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr ""
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr ""
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr ""
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr ""
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr ""
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr ""
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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 ""
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr ""
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr ""
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr ""
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr ""
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr ""
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr ""
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr ""
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr ""
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr ""
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr ""
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr ""
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr ""
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr ""
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr ""
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr ""
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr ""
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr ""
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr ""
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr ""
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr ""
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr ""
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr ""
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr ""
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr ""
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr ""
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr ""
+
+#: index.docbook:323
+msgid "<any>"
+msgstr ""
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr ""
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr ""
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1068 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr ""
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr ""
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr ""
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr ""
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr ""
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr ""
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr ""
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr ""
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr ""
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr ""
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr ""
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr ""
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr ""
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr ""
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr ""
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr ""
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr ""
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr ""
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr ""
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr ""
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr ""
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr ""
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr ""
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr ""
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr ""
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr ""
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr ""
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr ""
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr ""
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr ""
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr ""
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr ""
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr ""
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr ""
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr ""
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr ""
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr ""
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr ""
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr ""
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr ""
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr ""
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr ""
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr ""
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr ""
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr ""
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr ""
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr ""
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr ""
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr ""
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr ""
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr ""
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr ""
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr ""
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr ""
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr ""
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr ""
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr ""
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr ""
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr ""
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr ""
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr ""
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr ""
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr ""
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr ""
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr ""
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr ""
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr ""
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr ""
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr ""
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr ""
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr ""
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr ""
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr ""
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr ""
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr ""
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr ""
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr ""
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr ""
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr ""
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr ""
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr ""
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr ""
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr ""
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr ""
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr ""
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr ""
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr ""
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr ""
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr ""
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr ""
+
+#: index.docbook:603
+msgid "Type"
+msgstr ""
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr ""
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr ""
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr ""
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr ""
+
+#: index.docbook:612
+msgid "memory"
+msgstr ""
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr ""
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr ""
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr ""
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr ""
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr ""
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr ""
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr ""
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr ""
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr ""
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr ""
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr ""
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr ""
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr ""
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr ""
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr ""
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr ""
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr ""
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr ""
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr ""
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr ""
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr ""
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr ""
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr ""
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr ""
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr ""
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr ""
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr ""
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr ""
+
+#: index.docbook:775
+msgid "read-only"
+msgstr ""
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr ""
+
+#: index.docbook:777
+msgid "read-write"
+msgstr ""
+
+#: index.docbook:778
+msgid "transactional"
+msgstr ""
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr ""
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr ""
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr ""
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr ""
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr ""
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr ""
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr ""
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr ""
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr ""
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr ""
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr ""
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr ""
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr ""
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr ""
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr ""
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr ""
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr ""
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr ""
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr ""
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr ""
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr ""
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr ""
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr ""
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr ""
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr ""
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr ""
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr ""
+
+#: index.docbook:994
+msgid "sets"
+msgstr ""
+
+#: index.docbook:997
+msgid "bags"
+msgstr ""
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr ""
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr ""
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr ""
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr ""
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr ""
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr ""
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr ""
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr ""
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr ""
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr ""
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr ""
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr ""
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr ""
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr ""
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr ""
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr ""
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr ""
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr ""
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr ""
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr ""
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr ""
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr ""
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr ""
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr ""
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr ""
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr ""
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr ""
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr ""
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr ""
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr ""
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr ""
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr ""
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr ""
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr ""
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr ""
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr ""
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr ""
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr ""
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,446 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr ""
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr ""
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr ""
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr ""
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr ""
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr ""
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr ""
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr ""
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr ""
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr ""
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr ""
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr ""
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr ""
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr ""
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr ""
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr ""
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr ""
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr ""
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr ""
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr ""
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr ""
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr ""
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr ""
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr ""
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr ""
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr ""
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr ""
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr ""
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr ""
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr ""
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr ""
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr ""
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr ""
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr ""
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr ""
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr ""
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr ""
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr ""
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr ""
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr ""
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr ""
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr ""
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr ""
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr ""
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr ""
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr ""
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr ""
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr ""
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr ""
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr ""
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr ""
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr ""
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr ""
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr ""
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr ""
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr ""
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr ""
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr ""
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,484 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr ""
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr ""
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr ""
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr ""
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr ""
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr ""
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr ""
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr ""
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr ""
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr ""
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:81
+msgid "Associations"
+msgstr ""
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr ""
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr ""
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr ""
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr ""
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr ""
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr ""
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr ""
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr ""
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr ""
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr ""
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr ""
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr ""
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr ""
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr ""
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr ""
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr ""
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr ""
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr ""
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr ""
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr ""
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr ""
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr ""
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr ""
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr ""
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1275 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr ""
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr ""
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr ""
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr ""
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr ""
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr ""
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr ""
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr ""
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr ""
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr ""
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr ""
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr ""
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr ""
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr ""
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr ""
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr ""
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr ""
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr ""
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr ""
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr ""
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr ""
+
+#: index.docbook:103
+msgid "inner join"
+msgstr ""
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr ""
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr ""
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr ""
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr ""
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr ""
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr ""
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr ""
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr ""
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr ""
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr ""
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr ""
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr ""
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr ""
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr ""
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr ""
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr ""
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr ""
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr ""
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr ""
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr ""
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr ""
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr ""
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr ""
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr ""
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr ""
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr ""
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr ""
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr ""
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr ""
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr ""
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr ""
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr ""
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr ""
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr ""
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr ""
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr ""
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr ""
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr ""
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr ""
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr ""
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr ""
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr ""
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr ""
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr ""
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr ""
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr ""
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr ""
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr ""
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr ""
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr ""
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr ""
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr ""
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr ""
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr ""
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr ""
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr ""
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr ""
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr ""
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr ""
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr ""
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr ""
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr ""
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr ""
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr ""
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr ""
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr ""
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr ""
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr ""
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr ""
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr ""
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr ""
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr ""
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr ""
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr ""
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr ""
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr ""
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr ""
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr ""
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr ""
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr ""
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr ""
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr ""
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr ""
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr ""
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr ""
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr ""
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr ""
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr ""
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr ""
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr ""
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr ""
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr ""
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr ""
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr ""
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr ""
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr ""
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr ""
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr ""
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr ""
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr ""
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr ""
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr ""
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr ""
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr ""
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr ""
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr ""
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr ""
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr ""
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr ""
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr ""
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr ""
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr ""
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr ""
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr ""
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr ""
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr ""
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr ""
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr ""
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr ""
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr ""
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr ""
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr ""
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr ""
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr ""
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr ""
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr ""
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr ""
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr ""
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr ""
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr ""
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr ""
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr ""
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr ""
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr ""
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr ""
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr ""
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr ""
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr ""
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr ""
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr ""
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr ""
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr ""
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr ""
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr ""
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr ""
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr ""
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr ""
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr ""
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr ""
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr ""
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr ""
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr ""
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr ""
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr ""
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr ""
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr ""
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr ""
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr ""
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr ""
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr ""
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr ""
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr ""
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr ""
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr ""
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr ""
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr ""
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr ""
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr ""
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr ""
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr ""
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr ""
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr ""
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr ""
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr ""
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr ""
+
+#: index.docbook:985
+msgid "Components"
+msgstr ""
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr ""
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr ""
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr ""
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr ""
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr ""
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr ""
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr ""
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr ""
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr ""
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,818 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr ""
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr ""
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr ""
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr ""
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr ""
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr ""
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr ""
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr ""
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr ""
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr ""
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr ""
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr ""
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr ""
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr ""
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr ""
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr ""
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr ""
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr ""
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr ""
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr ""
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr ""
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr ""
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr ""
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr ""
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr ""
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr ""
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr ""
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr ""
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr ""
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr ""
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr ""
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr ""
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr ""
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr ""
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr ""
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr ""
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr ""
+
+#: index.docbook:219
+msgid "Description"
+msgstr ""
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr ""
+
+#: index.docbook:223
+msgid "Example"
+msgstr ""
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr ""
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr ""
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr ""
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr ""
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr ""
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr ""
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr ""
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr ""
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr ""
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr ""
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr ""
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr ""
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr ""
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr ""
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr ""
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr ""
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr ""
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr ""
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr ""
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr ""
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr ""
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr ""
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr ""
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr ""
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr ""
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr ""
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr ""
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr ""
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr ""
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr ""
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr ""
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr ""
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr ""
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr ""
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr ""
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr ""
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr ""
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr ""
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr ""
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr ""
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr ""
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr ""
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr ""
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr ""
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr ""
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr ""
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr ""
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr ""
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr ""
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr ""
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr ""
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr ""
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr ""
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr ""
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr ""
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr ""
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr ""
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr ""
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr ""
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr ""
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr ""
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr ""
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr ""
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr ""
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr ""
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr ""
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr ""
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr ""
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr ""
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr ""
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr ""
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr ""
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr ""
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr ""
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr ""
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,12 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,982 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr ""
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr ""
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr ""
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr ""
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr ""
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr ""
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr ""
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr ""
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr ""
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr ""
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr ""
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr ""
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr ""
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr ""
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr ""
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr ""
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr ""
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr ""
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr ""
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr ""
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr ""
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr ""
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr ""
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr ""
+
+#: index.docbook:219
+msgid "Querying"
+msgstr ""
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr ""
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr ""
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr ""
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr ""
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr ""
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr ""
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr ""
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr ""
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr ""
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr ""
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr ""
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr ""
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr ""
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr ""
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr ""
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr ""
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr ""
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr ""
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr ""
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr ""
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr ""
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr ""
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr ""
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr ""
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr ""
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr ""
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr ""
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr ""
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr ""
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr ""
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr ""
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr ""
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr ""
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr ""
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr ""
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr ""
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr ""
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr ""
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr ""
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr ""
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr ""
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr ""
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr ""
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr ""
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr ""
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr ""
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr ""
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr ""
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr ""
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr ""
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr ""
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr ""
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr ""
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr ""
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr ""
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr ""
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr ""
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr ""
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr ""
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr ""
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr ""
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr ""
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr ""
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr ""
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr ""
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr ""
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr ""
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr ""
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr ""
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr ""
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr ""
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr ""
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr ""
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr ""
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr ""
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr ""
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr ""
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr ""
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr ""
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr ""
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr ""
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr ""
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr ""
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr ""
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr ""
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr ""
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr ""
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr ""
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr ""
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr ""
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr ""
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr ""
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr ""
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr ""
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr ""
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr ""
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr ""
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr ""
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr ""
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr ""
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr ""
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr ""
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr ""
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr ""
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr ""
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr ""
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr ""
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr ""
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr ""
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr ""
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr ""
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr ""
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr ""
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,662 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr ""
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr ""
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr ""
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr ""
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr ""
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr ""
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr ""
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr ""
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr ""
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr ""
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr ""
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr ""
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr ""
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr ""
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr ""
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr ""
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr ""
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr ""
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr ""
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr ""
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr ""
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr ""
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr ""
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr ""
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr ""
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr ""
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "Summary"
+msgstr ""
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr ""
+
+#: index.docbook:164
+msgid "Values"
+msgstr ""
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr ""
+
+#: index.docbook:170
+msgid "length"
+msgstr ""
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr ""
+
+#: index.docbook:172
+msgid "column length"
+msgstr ""
+
+#: index.docbook:175
+msgid "precision"
+msgstr ""
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr ""
+
+#: index.docbook:180
+msgid "scale"
+msgstr ""
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr ""
+
+#: index.docbook:185
+msgid "not-null"
+msgstr ""
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr ""
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr ""
+
+#: index.docbook:190
+msgid "unique"
+msgstr ""
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr ""
+
+#: index.docbook:195
+msgid "index"
+msgstr ""
+
+#: index.docbook:196
+msgid "index_name"
+msgstr ""
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr ""
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr ""
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr ""
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr ""
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr ""
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr ""
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr ""
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr ""
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr ""
+
+#: index.docbook:225
+msgid "default"
+msgstr ""
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr ""
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr ""
+
+#: index.docbook:232
+msgid "check"
+msgstr ""
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr ""
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr ""
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr ""
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr ""
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr ""
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr ""
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr ""
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr ""
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr ""
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr ""
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr ""
+
+#: index.docbook:289
+msgid "--drop"
+msgstr ""
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr ""
+
+#: index.docbook:293
+msgid "--create"
+msgstr ""
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr ""
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr ""
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr ""
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr ""
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr ""
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr ""
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr ""
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr ""
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr ""
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr ""
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr ""
+
+#: index.docbook:317
+msgid "--format"
+msgstr ""
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr ""
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr ""
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr ""
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr ""
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr ""
+
+#: index.docbook:337
+msgid "Properties"
+msgstr ""
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr ""
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr ""
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr ""
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr ""
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr ""
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr ""
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr ""
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr ""
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr ""
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr ""
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr ""
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr ""
+
+#: index.docbook:381
+msgid "database user"
+msgstr ""
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: index.docbook:385
+msgid "user password"
+msgstr ""
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr ""
+
+#: index.docbook:389
+msgid "dialect"
+msgstr ""
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr ""
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr ""
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr ""
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr ""
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr ""
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr ""
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr ""
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr ""
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr ""
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr ""
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr ""
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr ""
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr ""
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr ""
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr ""
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr ""
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr ""
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr ""
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr ""
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,673 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr ""
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr ""
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr ""
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr ""
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr ""
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr ""
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr ""
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr ""
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr ""
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr ""
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr ""
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr ""
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr ""
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr ""
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr ""
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr ""
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr ""
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr ""
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr ""
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr ""
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr ""
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr ""
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr ""
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr ""
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr ""
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr ""
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr ""
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr ""
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr ""
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr ""
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr ""
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr ""
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr ""
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr ""
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr ""
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr ""
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr ""
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr ""
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr ""
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr ""
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr ""
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr ""
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr ""
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr ""
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr ""
+
+#: index.docbook:395
+msgid "close the session"
+msgstr ""
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr ""
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr ""
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr ""
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr ""
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr ""
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr ""
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr ""
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr ""
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr ""
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr ""
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr ""
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr ""
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr ""
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr ""
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr ""
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr ""
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr ""
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr ""
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr ""
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr ""
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr ""
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr ""
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr ""
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr ""
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr ""
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr ""
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr ""
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr ""
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr ""
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr ""
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr ""
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr ""
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr ""
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr ""
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr ""
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr ""
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr ""
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr ""
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr ""
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr ""
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr ""
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr ""
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr ""
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr ""
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr ""
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr ""
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr ""
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr ""
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr ""
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr ""
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr ""
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr ""
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr ""
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr ""
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr ""
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr ""
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr ""
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr ""
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr ""
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr ""
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr ""
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr ""
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr ""
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr ""
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr ""
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr ""
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr ""
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr ""
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr ""
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr ""
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr ""
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr ""
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr ""
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr ""
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr ""
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr ""
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1315 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr ""
+
+#: index.docbook:10
+msgid "Preface"
+msgstr ""
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr ""
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr ""
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr ""
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr ""
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr ""
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr ""
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr ""
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr ""
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr ""
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr ""
+
+#: index.docbook:68
+msgid "The first class"
+msgstr ""
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr ""
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr ""
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr ""
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr ""
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr ""
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr ""
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr ""
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr ""
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr ""
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr ""
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr ""
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr ""
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr ""
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr ""
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr ""
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr ""
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr ""
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr ""
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr ""
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr ""
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr ""
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr ""
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr ""
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr ""
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr ""
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr ""
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr ""
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr ""
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr ""
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr ""
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr ""
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr ""
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr ""
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr ""
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr ""
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr ""
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr ""
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr ""
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr ""
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr ""
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr ""
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr ""
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr ""
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr ""
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr ""
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr ""
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr ""
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr ""
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr ""
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr ""
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr ""
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr ""
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr ""
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr ""
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr ""
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr ""
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr ""
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr ""
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr ""
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr ""
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr ""
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr ""
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr ""
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr ""
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr ""
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr ""
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr ""
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr ""
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr ""
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr ""
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr ""
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr ""
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr ""
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr ""
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr ""
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr ""
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr ""
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr ""
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr ""
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr ""
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr ""
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr ""
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr ""
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr ""
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr ""
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr ""
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr ""
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr ""
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr ""
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr ""
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr ""
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr ""
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr ""
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr ""
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr ""
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr ""
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr ""
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr ""
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr ""
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr ""
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr ""
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr ""
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr ""
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr ""
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr ""
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr ""
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr ""
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr ""
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr ""
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr ""
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr ""
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr ""
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr ""
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr ""
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr ""
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr ""
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr ""
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr ""
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr ""
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr ""
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr ""
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr ""
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr ""
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr ""
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr ""
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr ""
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr ""
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr ""
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr ""
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr ""
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,284 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr ""
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr ""
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr ""
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr ""
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr ""
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr ""
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr ""
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr ""
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr ""
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr ""
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr ""
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr ""
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr ""
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr ""
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr ""
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr ""
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr ""
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr ""
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr ""
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr ""
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr ""
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr ""
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr ""
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/pt-BR/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/pt-BR/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/pt-BR/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/Hibernate_Reference.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/Hibernate_Reference.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/Hibernate_Reference.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,24 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:26
+msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
+msgstr "HIBERNATE - 符åˆJavaä¹ æƒ¯çš„å…³ç³»æ•°æ®åº“æŒä¹…化"
+
+#: index.docbook:27
+msgid "Hibernate Reference Documentation"
+msgstr "Hibernateå‚考文档"
+
+#: index.docbook:41
+msgid "©rightHolder;"
+msgstr "©rightHolder;"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/architecture.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/architecture.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/architecture.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,216 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Architecture"
+msgstr ""
+
+#: index.docbook:24
+msgid "Overview"
+msgstr ""
+
+#: index.docbook:26
+msgid "A (very) high-level view of the Hibernate architecture:"
+msgstr ""
+
+#: index.docbook:39
+msgid "This diagram shows Hibernate using the database and configuration data to provide persistence services (and persistent objects) to the application."
+msgstr ""
+
+#: index.docbook:44
+msgid "We would like to show a more detailed view of the runtime architecture. Unfortunately, Hibernate is flexible and supports several approaches. We will show the two extremes. The \"lite\" 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 ""
+
+#: index.docbook:61
+msgid "The \"full cream\" architecture abstracts the application away from the underlying JDBC/JTA APIs and lets Hibernate take care of the details."
+msgstr ""
+
+#: index.docbook:75
+msgid "Heres some definitions of the objects in the diagrams:"
+msgstr ""
+
+#: index.docbook:80
+msgid "SessionFactory (<literal>org.hibernate.SessionFactory</literal>)"
+msgstr ""
+
+#: index.docbook:82
+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>. Might hold an optional (second-level) cache of data that is reusable between transactions, at a process- or cluster-level."
+msgstr ""
+
+#: index.docbook:92
+msgid "Session (<literal>org.hibernate.Session</literal>)"
+msgstr ""
+
+#: index.docbook:94
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. Wraps a JDBC connection. Factory for <literal>Transaction</literal>. Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier."
+msgstr ""
+
+#: index.docbook:104
+msgid "Persistent objects and collections"
+msgstr ""
+
+#: index.docbook:106
+msgid "Short-lived, single threaded objects containing persistent state and business function. These might be ordinary JavaBeans/POJOs, the only special thing about them is that they are currently associated with (exactly one) <literal>Session</literal>. As soon as the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (e.g. directly as data transfer objects to and from presentation)."
+msgstr ""
+
+#: index.docbook:117
+msgid "Transient and detached objects and collections"
+msgstr ""
+
+#: index.docbook:119
+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 ""
+
+#: index.docbook:128
+msgid "Transaction (<literal>org.hibernate.Transaction</literal>)"
+msgstr ""
+
+#: index.docbook:130
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. Abstracts application from 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 ""
+
+#: index.docbook:141
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr ""
+
+#: index.docbook:143
+msgid "(Optional) A factory for (and pool of) JDBC connections. Abstracts application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. Not exposed to application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: index.docbook:151
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr ""
+
+#: index.docbook:153
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. Not exposed to the application, but can be extended/implemented by the developer."
+msgstr ""
+
+#: index.docbook:160
+msgid "Extension Interfaces"
+msgstr ""
+
+#: index.docbook:162
+msgid "Hibernate offers many optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr ""
+
+#: index.docbook:171
+msgid "Given a \"lite\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to talk to JTA or JDBC directly."
+msgstr ""
+
+#: index.docbook:179
+msgid "Instance states"
+msgstr ""
+
+#: index.docbook:180
+msgid "An instance of a persistent classes may be in one of three different states, which are defined with respect to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context:"
+msgstr ""
+
+#: index.docbook:188
+msgid "transient"
+msgstr ""
+
+#: index.docbook:190
+msgid "The instance is not, and has never been associated with any persistence context. It has no persistent identity (primary key value)."
+msgstr ""
+
+#: index.docbook:198
+msgid "persistent"
+msgstr ""
+
+#: index.docbook:200
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and, perhaps, a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity (in-memory location of the object)."
+msgstr ""
+
+#: index.docbook:212
+msgid "detached"
+msgstr ""
+
+#: index.docbook:214
+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, perhaps, a corrsponding row in the database. For detached instances, Hibernate makes no guarantees about the relationship between persistent identity and Java identity."
+msgstr ""
+
+#: index.docbook:229
+msgid "JMX Integration"
+msgstr ""
+
+#: index.docbook:231
+msgid "JMX is the J2EE standard for management of Java components. Hibernate may be managed via a JMX standard service. We provide an MBean implementation in the distribution, <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr ""
+
+#: index.docbook:237
+msgid "For an example how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. On JBoss AS, you also get these benefits if you deploy using JMX:"
+msgstr ""
+
+#: index.docbook:245
+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 you no longer have to manually open and close the <literal>Session</literal>, this becomes the job of a JBoss EJB interceptor. You also don't have to worry about transaction demarcation in your code anymore (unless you'd like to write a portable persistence layer of course, use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:257
+msgid "<emphasis>HAR deployment:</emphasis> Usually you deploy the Hibernate JMX service using a JBoss service deployment descriptor (in an EAR and/or SAR file), it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still have to name all your mapping files in the deployment descriptor. If you decide to use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr ""
+
+#: index.docbook:268
+msgid "Consult the JBoss AS user guide for more information about these options."
+msgstr ""
+
+#: index.docbook:272
+msgid "Another feature available as a JMX service are runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\"/>."
+msgstr ""
+
+#: index.docbook:279
+msgid "JCA Support"
+msgstr ""
+
+#: index.docbook:280
+msgid "Hibernate may also be configured as a JCA connector. Please see the website for more details. Please note that Hibernate JCA support is still considered experimental."
+msgstr ""
+
+#: index.docbook:287
+msgid "Contextual Sessions"
+msgstr ""
+
+#: index.docbook:288
+msgid "Most applications using Hibernate need some form of \"contextual\" sessions, 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; and 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 ""
+
+#: index.docbook:297
+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. The Hibernate team maintains that, given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations out there, 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 is all you should ever need to use."
+msgstr ""
+
+#: index.docbook:307
+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 ""
+
+#: index.docbook:314
+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 ""
+
+#: index.docbook:324
+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 ""
+
+#: index.docbook:332
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal> - current sessions are tracked by thread of execution. Again, see the Javadocs for details."
+msgstr ""
+
+#: index.docbook:338
+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 never open, flush, or close a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:347
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model, 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 programatic transaction demarcation in plain JSE without JTA, you are adviced to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, use the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you don't need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\"/> for more information and code examples."
+msgstr ""
+
+#: index.docbook:359
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. Note that for backwards compatibility, if this config param 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 ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/association_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/association_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/association_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,608 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:6
+msgid "Association Mappings"
+msgstr ""
+
+#: index.docbook:9
+msgid "Introduction"
+msgstr ""
+
+#: index.docbook:11
+msgid "Association mappings are the often most difficult thing to get right. In this section we'll go through the canonical cases one by one, starting with unidirectional mappings, and then considering the bidirectional cases. We'll use <literal>Person</literal> and <literal>Address</literal> in all the examples."
+msgstr ""
+
+#: index.docbook:19
+msgid "We'll classify associations by whether or not they map to an intervening join table, and by multiplicity."
+msgstr ""
+
+#: index.docbook:24
+msgid "Nullable foreign keys are not considered good practice in traditional data modelling, so all our examples use not null foreign keys. This is not a requirement of Hibernate, and the mappings will all work if you drop the nullability constraints."
+msgstr ""
+
+#: index.docbook:34
+msgid "Unidirectional associations"
+msgstr ""
+
+#: index.docbook:37, index.docbook:108
+msgid "many to one"
+msgstr ""
+
+#: index.docbook:39
+msgid "A <emphasis>unidirectional many-to-one association</emphasis> is the most common kind of unidirectional association."
+msgstr ""
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:45, index.docbook:161
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:50, index.docbook:121, index.docbook:185, index.docbook:225
+msgid "one to one"
+msgstr ""
+
+#: index.docbook:52
+msgid "A <emphasis>unidirectional one-to-one association on a foreign key</emphasis> is almost identical. The only difference is the column unique constraint."
+msgstr ""
+
+#: index.docbook:57
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:58, index.docbook:193
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:60
+msgid "A <emphasis>unidirectional one-to-one association on a primary key</emphasis> usually uses a special id generator. (Notice that we've reversed the direction of the association in this example.)"
+msgstr ""
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:67, index.docbook:201
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( personId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:72, index.docbook:94
+msgid "one to many"
+msgstr ""
+
+#: index.docbook:74
+msgid "A <emphasis>unidirectional one-to-many association on a foreign key</emphasis> is a very unusual case, and is not really recommended."
+msgstr ""
+
+#: index.docbook:79
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\">\n"
+ " <key column=\"personId\" \n"
+ " not-null=\"true\"/>\n"
+ " <one-to-many class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:80
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key, personId bigint not null )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:82
+msgid "We think it's better to use a join table for this kind of association."
+msgstr ""
+
+#: index.docbook:91
+msgid "Unidirectional associations with join tables"
+msgstr ""
+
+#: index.docbook:96
+msgid "A <emphasis>unidirectional one-to-many association on a join table</emphasis> is much preferred. Notice that by specifying <literal>unique=\"true\"</literal>, we have changed the multiplicity from many-to-many to one-to-many."
+msgstr ""
+
+#: index.docbook:102
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "A <emphasis>unidirectional many-to-one association on a join table</emphasis> is quite common when the association is optional."
+msgstr ""
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:116
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:123
+msgid "A <emphasis>unidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:129, index.docbook:233
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:134, index.docbook:238
+msgid "many to many"
+msgstr ""
+
+#: index.docbook:136
+msgid "Finally, we have a <emphasis>unidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:141, index.docbook:246
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:148
+msgid "Bidirectional associations"
+msgstr ""
+
+#: index.docbook:151, index.docbook:211
+msgid "one to many / many to one"
+msgstr ""
+
+#: index.docbook:153
+msgid "A <emphasis>bidirectional many-to-one association</emphasis> is the most common kind of association. (This is the standard parent/child relationship.)"
+msgstr ""
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:163
+msgid "If you use a <literal>List</literal> (or other indexed collection) you need to set the <literal>key</literal> column of the foreign key to <literal>not null</literal>, and let Hibernate manage the association from the collections side to maintain the index of each element (making the other side virtually inverse by setting <literal>update=\"false\"</literal> and <literal>insert=\"false\"</literal>):"
+msgstr ""
+
+#: index.docbook:171
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\"\n"
+ " not-null=\"true\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\"/>\n"
+ " ...\n"
+ " <list name=\"people\">\n"
+ " <key column=\"addressId\" not-null=\"true\"/>\n"
+ " <list-index column=\"peopleIdx\"/>\n"
+ " <one-to-many class=\"Person\"/>\n"
+ " </list>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:173
+msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal><key></literal> element of the collection mapping if the underlying foreign key column is <literal>NOT NULL</literal>. Don't only declare <literal>not-null=\"true\"</literal> on a possible nested <literal><column></literal> element, but on the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:187
+msgid "A <emphasis>bidirectional one-to-one association on a foreign key</emphasis> is quite common."
+msgstr ""
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <many-to-one name=\"address\" \n"
+ " column=\"addressId\" \n"
+ " unique=\"true\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " property-ref=\"address\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:195
+msgid "A <emphasis>bidirectional one-to-one association on a primary key</emphasis> uses the special id generator."
+msgstr ""
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <one-to-one name=\"address\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">person</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <one-to-one name=\"person\" \n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:208
+msgid "Bidirectional associations with join tables"
+msgstr ""
+
+#: index.docbook:213
+msgid "A <emphasis>bidirectional one-to-many association on a join table</emphasis>. Note that the <literal>inverse=\"true\"</literal> can go on either end of the association, on the collection, or on the join."
+msgstr ""
+
+#: index.docbook:219
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" \n"
+ " table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " unique=\"true\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " inverse=\"true\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\"\n"
+ " not-null=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[\n"
+ "create table Person ( personId bigint not null primary key )\n"
+ "create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )\n"
+ "create table Address ( addressId bigint not null primary key )\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "A <emphasis>bidirectional one-to-one association on a join table</emphasis> is extremely unusual, but possible."
+msgstr ""
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\">\n"
+ " <key column=\"personId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"address\"\n"
+ " column=\"addressId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <join table=\"PersonAddress\" \n"
+ " optional=\"true\"\n"
+ " inverse=\"true\">\n"
+ " <key column=\"addressId\" \n"
+ " unique=\"true\"/>\n"
+ " <many-to-one name=\"person\"\n"
+ " column=\"personId\" \n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ " </join>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:240
+msgid "Finally, we have a <emphasis>bidirectional many-to-many association</emphasis>."
+msgstr ""
+
+#: index.docbook:244
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\" column=\"personId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"addresses\" table=\"PersonAddress\">\n"
+ " <key column=\"personId\"/>\n"
+ " <many-to-many column=\"addressId\"\n"
+ " class=\"Address\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ " <id name=\"id\" column=\"addressId\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <set name=\"people\" inverse=\"true\" table=\"PersonAddress\">\n"
+ " <key column=\"addressId\"/>\n"
+ " <many-to-many column=\"personId\"\n"
+ " class=\"Person\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:253
+msgid "More complex association mappings"
+msgstr ""
+
+#: index.docbook:255
+msgid "More complex association joins are <emphasis>extremely</emphasis> rare. Hibernate makes it possible to handle more complex situations using SQL fragments embedded in the mapping document. For example, if a table with historical account information data defines <literal>accountNumber</literal>, <literal>effectiveEndDate</literal> and <literal>effectiveStartDate</literal>columns, mapped as follows:"
+msgstr ""
+
+#: index.docbook:264
+msgid ""
+ "<![CDATA[<properties name=\"currentAccountKey\">\n"
+ " <property name=\"accountNumber\" type=\"string\" not-null=\"true\"/>\n"
+ " <property name=\"currentAccount\" type=\"boolean\">\n"
+ " <formula>case when effectiveEndDate is null then 1 else 0 end</formula>\n"
+ " </property>\n"
+ "</properties>\n"
+ "<property name=\"effectiveEndDate\" type=\"date\"/>\n"
+ "<property name=\"effectiveStateDate\" type=\"date\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:266
+msgid "Then we can map an association to the <emphasis>current</emphasis> instance (the one with null <literal>effectiveEndDate</literal>) using:"
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<many-to-one name=\"currentAccountInfo\" \n"
+ " property-ref=\"currentAccountKey\"\n"
+ " class=\"AccountInfo\">\n"
+ " <column name=\"accountNumber\"/>\n"
+ " <formula>'1'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "In a more complex example, imagine that the association between <literal>Employee</literal> and <literal>Organization</literal> is maintained in an <literal>Employment</literal> table full of historical employment data. Then an association to the employee's <emphasis>most recent</emphasis> employer (the one with the most recent <literal>startDate</literal>) might be mapped this way:"
+msgstr ""
+
+#: index.docbook:281
+msgid ""
+ "<![CDATA[<join>\n"
+ " <key column=\"employeeId\"/>\n"
+ " <subselect>\n"
+ " select employeeId, orgId \n"
+ " from Employments \n"
+ " group by orgId \n"
+ " having startDate = max(startDate)\n"
+ " </subselect>\n"
+ " <many-to-one name=\"mostRecentEmployer\" \n"
+ " class=\"Organization\" \n"
+ " column=\"orgId\"/>\n"
+ "</join>]]>"
+msgstr ""
+
+#: index.docbook:283
+msgid "You can get quite creative with this functionality, but it is usually more practical to handle these kinds of cases using HQL or a criteria query."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/basic_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/basic_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/basic_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,2459 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Basic O/R Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "Mapping declaration"
+msgstr ""
+
+#: index.docbook:10
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations, not table declarations."
+msgstr ""
+
+#: index.docbook:17
+msgid "Note that, even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document, including XDoclet, Middlegen and AndroMDA."
+msgstr ""
+
+#: index.docbook:23
+msgid "Lets kick off with an example mapping:"
+msgstr ""
+
+#: index.docbook:27
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\"\n"
+ " table=\"cats\"\n"
+ " discriminator-value=\"C\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ "\n"
+ " <discriminator column=\"subclass\"\n"
+ " type=\"character\"/>\n"
+ "\n"
+ " <property name=\"weight\"/>\n"
+ "\n"
+ " <property name=\"birthdate\"\n"
+ " type=\"date\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"color\"\n"
+ " type=\"eg.types.ColorUserType\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"sex\"\n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <property name=\"litterId\"\n"
+ " column=\"litterId\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <many-to-one name=\"mother\"\n"
+ " column=\"mother_id\"\n"
+ " update=\"false\"/>\n"
+ "\n"
+ " <set name=\"kittens\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"litter_id\">\n"
+ " <key column=\"mother_id\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"DomesticCat\"\n"
+ " discriminator-value=\"D\">\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:29
+msgid "We will now discuss the content of the mapping document. We will only describe the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool. (For example the <literal> not-null</literal> attribute.)"
+msgstr ""
+
+#: index.docbook:40
+msgid "Doctype"
+msgstr ""
+
+#: index.docbook:42
+msgid "All XML mappings should declare the doctype shown. The actual DTD may be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal> or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check your DTD declaration against the contents of your claspath."
+msgstr ""
+
+#: index.docbook:52
+msgid "EntityResolver"
+msgstr ""
+
+#: index.docbook:53
+msgid "As mentioned previously, Hibernate will first attempt to resolve DTDs in its classpath. The manner in which it does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces."
+msgstr ""
+
+#: index.docbook:61
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounteres a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>; the resolver attempts to resolve these entities via the classlaoder which loaded the Hibernate classes."
+msgstr ""
+
+#: index.docbook:70
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounteres a systemId using a <literal>classpath://</literal> URL protocol; the resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr ""
+
+#: index.docbook:79
+msgid "An example of utilizing user namespacing:"
+msgstr ""
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\" [\n"
+ " <!ENTITY types SYSTEM \"classpath://your/domain/types.xml\">\n"
+ "]>\n"
+ "\n"
+ "<hibernate-mapping package=\"your.domain\">\n"
+ " <class name=\"MyEntity\">\n"
+ " <id name=\"id\" type=\"my-custom-id-type\">\n"
+ " ...\n"
+ " </id>\n"
+ " <class>\n"
+ " &types;\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:83
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>typedef."
+msgstr ""
+
+#: index.docbook:91
+msgid "hibernate-mapping"
+msgstr ""
+
+#: index.docbook:93
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If specified, tablenames will be qualified by the given schema and catalog names. If missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections which do not specify a <literal>cascade</literal> attribute. The <literal>auto-import</literal> attribute lets us use unqualified class names in the query language, by default."
+msgstr ""
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[<hibernate-mapping\n"
+ " schema=\"schemaName\"\n"
+ " catalog=\"catalogName\"\n"
+ " default-cascade=\"cascade_style\"\n"
+ " default-access=\"field|property|ClassName\"\n"
+ " default-lazy=\"true|false\"\n"
+ " auto-import=\"true|false\"\n"
+ " package=\"package.name\"\n"
+ " />]]>"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>schema</literal> (optional): The name of a database schema."
+msgstr ""
+
+#: index.docbook:122
+msgid "<literal>catalog</literal> (optional): The name of a database catalog."
+msgstr ""
+
+#: index.docbook:127
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): A default cascade style."
+msgstr ""
+
+#: index.docbook:133
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing all properties. Can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr ""
+
+#: index.docbook:140
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): The default value for unspecifed <literal>lazy</literal> attributes of class and collection mappings."
+msgstr ""
+
+#: index.docbook:147
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): Specifies whether we can use unqualified class names (of classes in this mapping) in the query language."
+msgstr ""
+
+#: index.docbook:154
+msgid "<literal>package</literal> (optional): Specifies a package prefix to assume for unqualified class names in the mapping document."
+msgstr ""
+
+#: index.docbook:162
+msgid "If you have two persistent classes with the same (unqualified) name, you should set <literal>auto-import=\"false\"</literal>. Hibernate will throw an exception if you attempt to assign two classes to the same \"imported\" name."
+msgstr ""
+
+#: index.docbook:168
+msgid "Note that the <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, e.g. <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr ""
+
+#: index.docbook:181
+msgid "<title>class</title>"
+msgstr ""
+
+#: index.docbook:183
+msgid "You may declare a persistent class using the <literal>class</literal> element:"
+msgstr ""
+
+#: index.docbook:211
+msgid ""
+ "<![CDATA[<class\n"
+ " name=\"ClassName\"\n"
+ " table=\"tableName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " mutable=\"true|false\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " select-before-update=\"true|false\"\n"
+ " polymorphism=\"implicit|explicit\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " persister=\"PersisterClass\"\n"
+ " batch-size=\"N\"\n"
+ " optimistic-lock=\"none|version|dirty|all\"\n"
+ " lazy=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " check=\"arbitrary sql check condition\"\n"
+ " rowid=\"rowid\"\n"
+ " subselect=\"SQL expression\"\n"
+ " abstract=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:214
+msgid "<literal>name</literal> (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr ""
+
+#: index.docbook:221
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): The name of its database table."
+msgstr ""
+
+#: index.docbook:227
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses, used for polymorphic behaviour. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr ""
+
+#: index.docbook:234
+msgid "<literal>mutable</literal> (optional, defaults to <literal>true</literal>): Specifies that instances of the class are (not) mutable."
+msgstr ""
+
+#: index.docbook:240, index.docbook:2204
+msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: index.docbook:246, index.docbook:2210
+msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr ""
+
+#: index.docbook:252
+msgid "<literal>proxy</literal> (optional): Specifies an interface to use for lazy initializing proxies. You may specify the name of the class itself."
+msgstr ""
+
+#: index.docbook:258
+msgid "<literal>dynamic-update</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>UPDATE</literal> SQL should be generated at runtime and contain only those columns whose values have changed."
+msgstr ""
+
+#: index.docbook:265
+msgid "<literal>dynamic-insert</literal> (optional, defaults to <literal>false</literal>): Specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr ""
+
+#: index.docbook:272
+msgid "<literal>select-before-update</literal> (optional, defaults to <literal>false</literal>): Specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. In certain cases (actually, only when a transient object has been associated with a new session using <literal>update()</literal>), this means that Hibernate will perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr ""
+
+#: index.docbook:282
+msgid "<literal>polymorphism</literal> (optional, defaults to <literal>implicit</literal>): Determines whether implicit or explicit query polymorphism is used."
+msgstr ""
+
+#: index.docbook:288
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class"
+msgstr ""
+
+#: index.docbook:294
+msgid "<literal>persister</literal> (optional): Specifies a custom <literal>ClassPersister</literal>."
+msgstr ""
+
+#: index.docbook:299
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for fetching instances of this class by identifier."
+msgstr ""
+
+#: index.docbook:305
+msgid "<literal>optimistic-lock</literal> (optional, defaults to <literal>version</literal>): Determines the optimistic locking strategy."
+msgstr ""
+
+#: index.docbook:311
+msgid "<literal>lazy</literal> (optional): Lazy fetching may be completely disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: index.docbook:317
+msgid "<literal>entity-name</literal> (optional, defaults to the class name): Hibernate3 allows a class to be mapped multiple times (to different tables, potentially), and allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr ""
+
+#: index.docbook:327
+msgid "<literal>check</literal> (optional): A SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr ""
+
+#: index.docbook:333
+msgid "<literal>rowid</literal> (optional): Hibernate can use so called ROWIDs on databases which support. E.g. on Oracle, Hibernate can use the <literal>rowid</literal> extra column for fast updates if you set this option to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr ""
+
+#: index.docbook:341
+msgid "<literal>subselect</literal> (optional): Maps an immutable and read-only entity to a database subselect. Useful if you want to have a view instead of a base table, but don't. See below for more information."
+msgstr ""
+
+#: index.docbook:348
+msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr ""
+
+#: index.docbook:356
+msgid "It is perfectly acceptable for the named persistent class to be an interface. You would then declare implementing classes of that interface using the <literal><subclass></literal> element. You may persist any <emphasis>static</emphasis> inner class. You should specify the class name using the standard form ie. <literal>eg.Foo$Bar</literal>."
+msgstr ""
+
+#: index.docbook:363
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, may not be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr ""
+
+#: index.docbook:368
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr ""
+
+#: index.docbook:375
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or the class and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class and that queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)."
+msgstr ""
+
+#: index.docbook:387
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You may, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal> or you might even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements persistence via, for example, stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example (of \"persistence\" to a <literal>Hashtable</literal>)."
+msgstr ""
+
+#: index.docbook:398
+msgid "Note that the <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses and so may also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. These settings may increase performance in some cases, but might actually decrease performance in others. Use judiciously."
+msgstr ""
+
+#: index.docbook:406
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is very useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:412
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr ""
+
+#: index.docbook:418
+msgid "<literal>version</literal> check the version/timestamp columns"
+msgstr ""
+
+#: index.docbook:423
+msgid "<literal>all</literal> check all columns"
+msgstr ""
+
+#: index.docbook:428
+msgid "<literal>dirty</literal> check the changed columns, allowing some concurrent updates"
+msgstr ""
+
+#: index.docbook:433
+msgid "<literal>none</literal> do not use optimistic locking"
+msgstr ""
+
+#: index.docbook:438
+msgid "We <emphasis>very</emphasis> strongly recommend that you use version/timestamp columns for optimistic locking with Hibernate. This is the optimal strategy with respect to performance and is the only strategy that correctly handles modifications made to detached instances (ie. when <literal>Session.merge()</literal> is used)."
+msgstr ""
+
+#: index.docbook:445
+msgid "There is no difference between a view and a base table for a Hibernate mapping, as expected this is transparent at the database level (note that some DBMS don't support views properly, especially with updates). Sometimes you want to use a view, but can't create one in the database (ie. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr ""
+
+#: index.docbook:453
+msgid ""
+ "<![CDATA[<class name=\"Summary\">\n"
+ " <subselect>\n"
+ " select item.name, max(bid.amount), count(*)\n"
+ " from item\n"
+ " join bid on bid.item_id = item.id\n"
+ " group by item.name\n"
+ " </subselect>\n"
+ " <synchronize table=\"item\"/>\n"
+ " <synchronize table=\"bid\"/>\n"
+ " <id name=\"name\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:455
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly, and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available as both as an attribute and a nested mapping element."
+msgstr ""
+
+#: index.docbook:465
+msgid "<title>id</title>"
+msgstr ""
+
+#: index.docbook:467
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr ""
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[<id\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " column=\"column_name\"\n"
+ " unsaved-value=\"null|any|none|undefined|id_value\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "\n"
+ " <generator class=\"generatorClass\"/>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:485
+msgid "<literal>name</literal> (optional): The name of the identifier property."
+msgstr ""
+
+#: index.docbook:490
+msgid "<literal>type</literal> (optional): A name that indicates the Hibernate type."
+msgstr ""
+
+#: index.docbook:495
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the primary key column."
+msgstr ""
+
+#: index.docbook:501
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): An identifier property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr ""
+
+#: index.docbook:509, index.docbook:1017, index.docbook:1156, index.docbook:1238, index.docbook:1345, index.docbook:1534, index.docbook:1708, index.docbook:1878, index.docbook:2457
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the property value."
+msgstr ""
+
+#: index.docbook:517
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
+msgstr ""
+
+#: index.docbook:522
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
+msgstr ""
+
+#: index.docbook:526
+msgid "There is an alternative <literal><composite-id></literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else."
+msgstr ""
+
+#: index.docbook:532
+msgid "Generator"
+msgstr ""
+
+#: index.docbook:534
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr ""
+
+#: index.docbook:541
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
+ " <param name=\"table\">uid_table</param>\n"
+ " <param name=\"column\">next_hi_value_column</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:543
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface; some applications may choose to provide their own specialized implementations. However, Hibernate provides a range of built-in implementations. There are shortcut names for the built-in generators:"
+msgstr ""
+
+#: index.docbook:551
+msgid "increment"
+msgstr ""
+
+#: index.docbook:553
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr ""
+
+#: index.docbook:562
+msgid "identity"
+msgstr ""
+
+#: index.docbook:564
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr ""
+
+#: index.docbook:572
+msgid "sequence"
+msgstr ""
+
+#: index.docbook:574
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr ""
+
+#: index.docbook:582
+msgid "hilo"
+msgstr ""
+
+#: index.docbook:584
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr ""
+
+#: index.docbook:594
+msgid "seqhilo"
+msgstr ""
+
+#: index.docbook:596
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr ""
+
+#: index.docbook:604
+msgid "uuid"
+msgstr ""
+
+#: index.docbook:606
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string, unique within a network (the IP address is used). The UUID is encoded as a string of hexadecimal digits of length 32."
+msgstr ""
+
+#: index.docbook:614
+msgid "guid"
+msgstr ""
+
+#: index.docbook:616
+msgid "uses a database-generated GUID string on MS SQL Server and MySQL."
+msgstr ""
+
+#: index.docbook:622
+msgid "native"
+msgstr ""
+
+#: index.docbook:624
+msgid "picks <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr ""
+
+#: index.docbook:632
+msgid "assigned"
+msgstr ""
+
+#: index.docbook:634
+msgid "lets the application to assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr ""
+
+#: index.docbook:642
+msgid "select"
+msgstr ""
+
+#: index.docbook:644
+msgid "retrieves a primary key assigned by a database trigger by selecting the row by some unique key and retrieving the primary key value."
+msgstr ""
+
+#: index.docbook:651
+msgid "foreign"
+msgstr ""
+
+#: index.docbook:653
+msgid "uses the identifier of another associated object. Usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr ""
+
+#: index.docbook:660
+msgid "sequence-identity"
+msgstr ""
+
+#: index.docbook:662
+msgid "a specialized sequence generation strategy which utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to actually return the generated identifier value as part of the insert statement execution. This strategy is only known to be supported on Oracle 10g drivers targetted for JDK 1.4. Note comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr ""
+
+#: index.docbook:679
+msgid "Hi/lo algorithm"
+msgstr ""
+
+#: index.docbook:680
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm, a favorite approach to identifier generation. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. The second uses an Oracle-style sequence (where supported)."
+msgstr ""
+
+#: index.docbook:687
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"hilo\">\n"
+ " <param name=\"table\">hi_value</param>\n"
+ " <param name=\"column\">next_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
+ " <generator class=\"seqhilo\">\n"
+ " <param name=\"sequence\">hi_value</param>\n"
+ " <param name=\"max_lo\">100</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:691
+msgid "Unfortunately, you can't use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate is using an application server datasource to obtain connections enlisted with JTA, you must properly configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: index.docbook:700
+msgid "UUID algorithm"
+msgstr ""
+
+#: index.docbook:701
+msgid "The UUID contains: IP address, startup time of the JVM (accurate to a quarter second), system time and a counter value (unique within the JVM). It's not possible to obtain a MAC address or memory address from Java code, so this is the best we can do without using JNI."
+msgstr ""
+
+#: index.docbook:710
+msgid "Identity columns and sequences"
+msgstr ""
+
+#: index.docbook:711
+msgid "For databases which support identity columns (DB2, MySQL, Sybase, MS SQL), you may use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you may use <literal>sequence</literal> style key generation. Both these strategies require two SQL queries to insert a new object."
+msgstr ""
+
+#: index.docbook:719
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">person_id_sequence</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:721
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
+ " <generator class=\"identity\"/>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:723
+msgid "For cross-platform development, the <literal>native</literal> strategy will choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies, dependant upon the capabilities of the underlying database."
+msgstr ""
+
+#: index.docbook:732
+msgid "Assigned identifiers"
+msgstr ""
+
+#: index.docbook:733
+msgid "If you want the application to assign identifiers (as opposed to having Hibernate generate them), you may use the <literal>assigned</literal> generator. This special generator will use the identifier value already assigned to the object's identifier property. This generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do no specify a <literal><generator></literal> element."
+msgstr ""
+
+#: index.docbook:742
+msgid "Choosing the <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>, forcing Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr ""
+
+#: index.docbook:752
+msgid "Primary keys assigned by triggers"
+msgstr ""
+
+#: index.docbook:753
+msgid "For legacy schemas only (Hibernate does not generate DDL with triggers)."
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
+ " <generator class=\"select\">\n"
+ " <param name=\"key\">socialSecurityNumber</param>\n"
+ " </generator>\n"
+ "</id>]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal> defined by the class, as a natural key, and a surrogate key named <literal>person_id</literal> whose value is generated by a trigger."
+msgstr ""
+
+#: index.docbook:771
+msgid "Enhanced identifier generators"
+msgstr ""
+
+#: index.docbook:773
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization (not having to query the database for every request for a new identifier value). These two new generators are intended to take the place of some of the named generators described above (starting in 3.3.x); however, they are included in the current releases and can be referenced by FQN."
+msgstr ""
+
+#: index.docbook:781
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended firstly as a replacement for the <literal>sequence</literal> generator and secondly as a better portability generator than <literal>native</literal> (because <literal>native</literal> (generally) chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics which can cause subtle isssues in applications eyeing portability). <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> however achieves portability in a different manner. It chooses between using a table or a sequence in the database to store its incrementing values depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic (in fact sequences are exactly what Hibernate tries to emmulate with its!
table-based generators). This generator has a number of configuration parameters:"
+msgstr ""
+
+#: index.docbook:795
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): The name of the sequence (or table) to be used."
+msgstr ""
+
+#: index.docbook:801
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typical named \"STARTS WITH\"."
+msgstr ""
+
+#: index.docbook:808
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typical named \"INCREMENT BY\"."
+msgstr ""
+
+#: index.docbook:815
+msgid "<literal>force_table_use</literal> (optional, defaults to <literal>false</literal>): Should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr ""
+
+#: index.docbook:822
+msgid "<literal>value_column</literal> (optional, defaults to <literal>next_val</literal>): Only relevant for table structures! The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: index.docbook:829
+msgid "<literal>optimizer</literal> (optional, defaults to <literal>none</literal>): See"
+msgstr ""
+
+#: index.docbook:836
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal> which is intended firstly as a replacement for the <literal>table</literal> generator (although it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>) and secondly as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> utilizing the notion of pluggable optimiziers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr ""
+
+#: index.docbook:846
+msgid "<literal>table_name</literal> (optional, defaults to <literal>hibernate_sequences</literal>): The name of the table to be used."
+msgstr ""
+
+#: index.docbook:852
+msgid "<literal>value_column_name</literal> (optional, defaults to <literal>next_val</literal>): The name of the column on the table which is used to hold the value."
+msgstr ""
+
+#: index.docbook:858
+msgid "<literal>segment_column_name</literal> (optional, defaults to <literal>sequence_name</literal>): The name of the column on the table which is used to hold the \"segement key\". This is the value which distinctly identifies which increment value to use."
+msgstr ""
+
+#: index.docbook:865
+msgid "<literal>segment_value</literal> (optional, defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr ""
+
+#: index.docbook:872
+msgid "<literal>segment_value_length</literal> (optional, defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr ""
+
+#: index.docbook:878
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr ""
+
+#: index.docbook:884
+msgid "<literal>increment_size</literal> (optional, defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr ""
+
+#: index.docbook:890
+msgid "<literal>optimizer</literal> (optional, defaults to <literal></literal>): See"
+msgstr ""
+
+#: index.docbook:900
+msgid "Identifier generator optimization"
+msgstr ""
+
+#: index.docbook:901
+msgid "For identifier generators which store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you'd ideally want to group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this notion."
+msgstr ""
+
+#: index.docbook:909
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): This says to not perform any optimizations, and hit the database each and every request."
+msgstr ""
+
+#: index.docbook:915
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\"; the <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr ""
+
+#: index.docbook:924
+msgid "<literal>pooled</literal>: like was discussed for <literal>hilo</literal>, this optimizers attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. <literal>increment_size</literal> here refers to the values coming from the database."
+msgstr ""
+
+#: index.docbook:937
+msgid "composite-id"
+msgstr ""
+
+#: index.docbook:939
+msgid ""
+ "<![CDATA[<composite-id\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " mapped=\"true|false\"\n"
+ " access=\"field|property|ClassName\">\n"
+ " node=\"element-name|.\"\n"
+ "\n"
+ " <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+ " <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
+ " ......\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:941
+msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr ""
+
+#: index.docbook:948
+msgid ""
+ "<![CDATA[<composite-id>\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:950
+msgid "Your persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implements <literal>Serializable</literal>."
+msgstr ""
+
+#: index.docbook:956
+msgid "Unfortunately, this approach to composite identifiers means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr ""
+
+#: index.docbook:965
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr ""
+
+#: index.docbook:971
+msgid ""
+ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+ " <key-property name=\"medicareNumber\"/>\n"
+ " <key-property name=\"dependent\"/>\n"
+ "</composite-id>]]>"
+msgstr ""
+
+#: index.docbook:973
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement. <literal>Serializable</literal>. The disadvantage of this approach is quite obvious—code duplication."
+msgstr ""
+
+#: index.docbook:982
+msgid "The following attributes are used to specify a mapped composite identifier:"
+msgstr ""
+
+#: index.docbook:988
+msgid "<literal>mapped</literal> (optional, defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr ""
+
+#: index.docbook:996
+msgid "<literal>class</literal> (optional, but required for a mapped composite identifier): The class used as a composite identifier."
+msgstr ""
+
+#: index.docbook:1003
+msgid "We will describe a third, even more convenient approach where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr ""
+
+#: index.docbook:1011
+msgid "<literal>name</literal> (optional, required for this approach): A property of component type that holds the composite identifier (see chapter 9)."
+msgstr ""
+
+#: index.docbook:1023
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The component class used as a composite identifier (see next section)."
+msgstr ""
+
+#: index.docbook:1030
+msgid "This third approach, an <emphasis>identifier component</emphasis> is the one we recommend for almost all applications."
+msgstr ""
+
+#: index.docbook:1038
+msgid "discriminator"
+msgstr ""
+
+#: index.docbook:1040
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy and declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types may be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr ""
+
+#: index.docbook:1058
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " column=\"discriminator_column\"\n"
+ " type=\"discriminator_type\"\n"
+ " force=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary sql expression\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1061
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>) the name of the discriminator column."
+msgstr ""
+
+#: index.docbook:1067
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>) a name that indicates the Hibernate type"
+msgstr ""
+
+#: index.docbook:1073
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>) \"force\" Hibernate to specify allowed discriminator values even when retrieving all instances of the root class."
+msgstr ""
+
+#: index.docbook:1080
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>) set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. (Tells Hibernate to not include the column in SQL <literal>INSERT</literal>s.)"
+msgstr ""
+
+#: index.docbook:1088
+msgid "<literal>formula</literal> (optional) an arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination."
+msgstr ""
+
+#: index.docbook:1096
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr ""
+
+#: index.docbook:1102
+msgid "The <literal>force</literal> attribute is (only) useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr ""
+
+#: index.docbook:1108
+msgid "Using the <literal>formula</literal> attribute you can declare an arbitrary SQL expression that will be used to evaluate the type of a row:"
+msgstr ""
+
+#: index.docbook:1113
+msgid ""
+ "<![CDATA[<discriminator\n"
+ " formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
+ " type=\"integer\"/>]]>"
+msgstr ""
+
+#: index.docbook:1118
+msgid "version (optional)"
+msgstr ""
+
+#: index.docbook:1120
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)."
+msgstr ""
+
+#: index.docbook:1136
+msgid ""
+ "<![CDATA[<version\n"
+ " column=\"version_column\"\n"
+ " name=\"propertyName\"\n"
+ " type=\"typename\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|negative|undefined\"\n"
+ " generated=\"never|always\"\n"
+ " insert=\"true|false\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1139
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of the column holding the version number."
+msgstr ""
+
+#: index.docbook:1145
+msgid "<literal>name</literal>: The name of a property of the persistent class."
+msgstr ""
+
+#: index.docbook:1150
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): The type of the version number."
+msgstr ""
+
+#: index.docbook:1162
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: index.docbook:1171
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this version property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1178
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): Specifies whether the version column should be included in SQL insert statements. May be set to <literal>false</literal> if and only if the database column is defined with a default value of <literal>0</literal>."
+msgstr ""
+
+#: index.docbook:1188
+msgid "Version numbers may be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr ""
+
+#: index.docbook:1193
+msgid "A version or timestamp property should never be null for a detached instance, so Hibernate will detect any instance with a null version or timestamp as transient, no matter what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid any problems with transitive reattachment in Hibernate, especially useful for people using assigned identifiers or composite keys!</emphasis>"
+msgstr ""
+
+#: index.docbook:1204
+msgid "timestamp (optional)"
+msgstr ""
+
+#: index.docbook:1206
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This is intended as an alternative to versioning. Timestamps are by nature a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr ""
+
+#: index.docbook:1222
+msgid ""
+ "<![CDATA[<timestamp\n"
+ " column=\"timestamp_column\"\n"
+ " name=\"propertyName\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unsaved-value=\"null|undefined\"\n"
+ " source=\"vm|db\"\n"
+ " generated=\"never|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1225
+msgid "<literal>column</literal> (optional - defaults to the property name): The name of a column holding the timestamp."
+msgstr ""
+
+#: index.docbook:1231
+msgid "<literal>name</literal>: The name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr ""
+
+#: index.docbook:1244
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): A version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. (<literal>undefined</literal> specifies that the identifier property value should be used.)"
+msgstr ""
+
+#: index.docbook:1253
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): From where should Hibernate retrieve the timestamp value? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\", but will be safer for use in clustered environments. Note also, that not all <literal>Dialect</literal>s are known to support retrieving of the database's current timestamp, while others might be unsafe for usage in locking due to lack of precision (Oracle 8 for example)."
+msgstr ""
+
+#: index.docbook:1265
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1274
+msgid "Note that <literal><timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr ""
+
+#: index.docbook:1284
+msgid "property"
+msgstr ""
+
+#: index.docbook:1286
+msgid "The <literal><property></literal> element declares a persistent, JavaBean style property of the class."
+msgstr ""
+
+#: index.docbook:1308
+msgid ""
+ "<![CDATA[<property\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " type=\"typename\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " generated=\"never|insert|always\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1311
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
+msgstr ""
+
+#: index.docbook:1317
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: index.docbook:1324
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgstr ""
+
+#: index.docbook:1329
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) : specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: index.docbook:1338
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr ""
+
+#: index.docbook:1351
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: index.docbook:1358
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr ""
+
+#: index.docbook:1365
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the columns."
+msgstr ""
+
+#: index.docbook:1371
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1379
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): Specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/>generated properties."
+msgstr ""
+
+#: index.docbook:1388
+msgid "<emphasis>typename</emphasis> could be:"
+msgstr ""
+
+#: index.docbook:1394
+msgid "The name of a Hibernate basic type (eg. <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal>)."
+msgstr ""
+
+#: index.docbook:1400
+msgid "The name of a Java class with a default basic type (eg. <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)."
+msgstr ""
+
+#: index.docbook:1406
+msgid "The name of a serializable Java class."
+msgstr ""
+
+#: index.docbook:1411
+msgid "The class name of a custom type (eg. <literal>com.illflow.type.MyCustomType</literal>)."
+msgstr ""
+
+#: index.docbook:1417
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property to take a guess at the correct Hibernate type. Hibernate will try to interpret the name of the return class of the property getter using rules 2, 3, 4 in that order. However, this is not always enough. In certain cases you will still need the <literal>type</literal> attribute. (For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type.)"
+msgstr ""
+
+#: index.docbook:1427
+msgid "The <literal>access</literal> attribute lets you control how Hibernate will access the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly, using reflection. You may specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr ""
+
+#: index.docbook:1436
+msgid "An especially powerful feature are derived properties. These properties are by definition read-only, the property value is computed at load time. You declare the computation as a SQL expression, this translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr ""
+
+#: index.docbook:1443
+msgid ""
+ "<![CDATA[\n"
+ "<property name=\"totalPrice\"\n"
+ " formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
+ " WHERE li.productId = p.productId\n"
+ " AND li.customerId = customerId\n"
+ " AND li.orderNumber = orderNumber )\"/>]]>"
+msgstr ""
+
+#: index.docbook:1445
+msgid "Note that you can reference the entities own table by not declaring an alias on a particular column (<literal>customerId</literal> in the given example). Also note that you can use the nested <literal><formula></literal> mapping element if you don't like to use the attribute."
+msgstr ""
+
+#: index.docbook:1455
+msgid "many-to-one"
+msgstr ""
+
+#: index.docbook:1457
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr ""
+
+#: index.docbook:1485
+msgid ""
+ "<![CDATA[<many-to-one\n"
+ " name=\"propertyName\"\n"
+ " column=\"column_name\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " fetch=\"join|select\"\n"
+ " update=\"true|false\"\n"
+ " insert=\"true|false\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " unique=\"true|false\"\n"
+ " not-null=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " formula=\"arbitrary SQL expression\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " index=\"index_name\"\n"
+ " unique_key=\"unique_key_id\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1488, index.docbook:1669, index.docbook:1855
+msgid "<literal>name</literal>: The name of the property."
+msgstr ""
+
+#: index.docbook:1493, index.docbook:2284
+msgid "<literal>column</literal> (optional): The name of the foreign key column. This may also be specified by nested <literal><column></literal> element(s)."
+msgstr ""
+
+#: index.docbook:1500, index.docbook:1674
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the associated class."
+msgstr ""
+
+#: index.docbook:1506
+msgid "<literal>cascade</literal> (optional): Specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: index.docbook:1512, index.docbook:1695
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): Chooses between outer-join fetching or sequential select fetching."
+msgstr ""
+
+#: index.docbook:1518
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>) specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application."
+msgstr ""
+
+#: index.docbook:1527
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: index.docbook:1540
+msgid "<literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a <literal>property-ref</literal>. This makes the association multiplicity effectively one to one."
+msgstr ""
+
+#: index.docbook:1548
+msgid "<literal>not-null</literal> (optional): Enable the DDL generation of a nullability constraint for the foreign key columns."
+msgstr ""
+
+#: index.docbook:1554
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1562
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr ""
+
+#: index.docbook:1572
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: index.docbook:1579, index.docbook:1733
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class."
+msgstr ""
+
+#: index.docbook:1585
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr ""
+
+#: index.docbook:1592
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are the names of Hibernate's basic operations, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as well as the special values <literal>delete-orphan</literal> and <literal>all</literal> and comma-separated combinations of operation names, for example, <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued associations (many-to-one and one-to-one associations) do not support orphan delete."
+msgstr ""
+
+#: index.docbook:1605
+msgid "A typical <literal>many-to-one</literal> declaration looks as simple as this:"
+msgstr ""
+
+#: index.docbook:1609
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
+msgstr ""
+
+#: index.docbook:1611
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is an ugly relational model. For example, suppose the <literal>Product</literal> class had a unique serial number, that is not the primary key. (The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool.)"
+msgstr ""
+
+#: index.docbook:1620
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr ""
+
+#: index.docbook:1622
+msgid "Then the mapping for <literal>OrderItem</literal> might use:"
+msgstr ""
+
+#: index.docbook:1626
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr ""
+
+#: index.docbook:1628
+msgid "This is certainly not encouraged, however."
+msgstr ""
+
+#: index.docbook:1632
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr ""
+
+#: index.docbook:1637
+msgid "If the referenced unique key is the property of a component, you may specify a property path:"
+msgstr ""
+
+#: index.docbook:1641
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr ""
+
+#: index.docbook:1646
+msgid "one-to-one"
+msgstr ""
+
+#: index.docbook:1648
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr ""
+
+#: index.docbook:1666
+msgid ""
+ "<![CDATA[<one-to-one\n"
+ " name=\"propertyName\"\n"
+ " class=\"ClassName\"\n"
+ " cascade=\"cascade_style\"\n"
+ " constrained=\"true|false\"\n"
+ " fetch=\"join|select\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " formula=\"any SQL expression\"\n"
+ " lazy=\"proxy|no-proxy|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name|@attribute-name|element/@attribute|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ " foreign-key=\"foreign_key_name\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:1680
+msgid "<literal>cascade</literal> (optional) specifies which operations should be cascaded from the parent object to the associated object."
+msgstr ""
+
+#: index.docbook:1686
+msgid "<literal>constrained</literal> (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool)."
+msgstr ""
+
+#: index.docbook:1701
+msgid "<literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr ""
+
+#: index.docbook:1714
+msgid "<literal>formula</literal> (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See <literal>org.hibernate.test.onetooneformula</literal> for an example.)"
+msgstr ""
+
+#: index.docbook:1722
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): By default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eager fetch the association!</emphasis>"
+msgstr ""
+
+#: index.docbook:1740
+msgid "There are two varieties of one-to-one association:"
+msgstr ""
+
+#: index.docbook:1744
+msgid "primary key associations"
+msgstr ""
+
+#: index.docbook:1747
+msgid "unique foreign key associations"
+msgstr ""
+
+#: index.docbook:1752
+msgid "Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value. So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!"
+msgstr ""
+
+#: index.docbook:1759
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal>, respectively."
+msgstr ""
+
+#: index.docbook:1764
+msgid "<![CDATA[<one-to-one name=\"person\" class=\"Person\"/>]]>"
+msgstr ""
+
+#: index.docbook:1765
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:1767
+msgid "Now we must ensure that the primary keys of related rows in the PERSON and EMPLOYEE tables are equal. We use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr ""
+
+#: index.docbook:1773
+msgid ""
+ "<![CDATA[<class name=\"person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"foreign\">\n"
+ " <param name=\"property\">employee</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " ...\n"
+ " <one-to-one name=\"employee\"\n"
+ " class=\"Employee\"\n"
+ " constrained=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:1775
+msgid "A newly saved instance of <literal>Person</literal> is then assigned the same primary key value as the <literal>Employee</literal> instance refered with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr ""
+
+#: index.docbook:1781
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, may be expressed as:"
+msgstr ""
+
+#: index.docbook:1786
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:1788
+msgid "And this association may be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr ""
+
+#: index.docbook:1793
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr ""
+
+#: index.docbook:1798
+msgid "natural-id"
+msgstr ""
+
+#: index.docbook:1800
+msgid ""
+ "<![CDATA[<natural-id mutable=\"true|false\"/>\n"
+ " <property ... />\n"
+ " <many-to-one ... />\n"
+ " ......\n"
+ "</natural-id>]]>"
+msgstr ""
+
+#: index.docbook:1802
+msgid "Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting."
+msgstr ""
+
+#: index.docbook:1811
+msgid "We strongly recommend that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr ""
+
+#: index.docbook:1816
+msgid "This mapping is not intended for use with entities with natural primary keys."
+msgstr ""
+
+#: index.docbook:1822
+msgid "<literal>mutable</literal> (optional, defaults to <literal>false</literal>): By default, natural identifier properties as assumed to be immutable (constant)."
+msgstr ""
+
+#: index.docbook:1832
+msgid "component, dynamic-component"
+msgstr ""
+
+#: index.docbook:1834
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components may, in turn, declare their own properties, components or collections. See \"Components\" below."
+msgstr ""
+
+#: index.docbook:1852
+msgid ""
+ "<![CDATA[<component\n"
+ " name=\"propertyName\"\n"
+ " class=\"className\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " lazy=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</component>]]>"
+msgstr ""
+
+#: index.docbook:1860
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): The name of the component (child) class."
+msgstr ""
+
+#: index.docbook:1866, index.docbook:1955
+msgid "<literal>insert</literal>: Do the mapped columns appear in SQL <literal>INSERT</literal>s?"
+msgstr ""
+
+#: index.docbook:1872, index.docbook:1961
+msgid "<literal>update</literal>: Do the mapped columns appear in SQL <literal>UPDATE</literal>s?"
+msgstr ""
+
+#: index.docbook:1884
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): Specifies that this component should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation)."
+msgstr ""
+
+#: index.docbook:1891
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this component do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty."
+msgstr ""
+
+#: index.docbook:1899, index.docbook:1975
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): Specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr ""
+
+#: index.docbook:1908
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr ""
+
+#: index.docbook:1913
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: index.docbook:1919
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>."
+msgstr ""
+
+#: index.docbook:1928
+msgid "properties"
+msgstr ""
+
+#: index.docbook:1930
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint."
+msgstr ""
+
+#: index.docbook:1946
+msgid ""
+ "<![CDATA[<properties\n"
+ " name=\"logicalName\"\n"
+ " insert=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <property ...../>\n"
+ " <many-to-one .... />\n"
+ " ........\n"
+ "</properties>]]>"
+msgstr ""
+
+#: index.docbook:1949
+msgid "<literal>name</literal>: The logical name of the grouping - <emphasis>not</emphasis> an actual property name."
+msgstr ""
+
+#: index.docbook:1967
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to these properties do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when these properties are dirty."
+msgstr ""
+
+#: index.docbook:1984
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
+msgstr ""
+
+#: index.docbook:1988
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"personNumber\"/>\n"
+ " ...\n"
+ " <properties name=\"name\"\n"
+ " unique=\"true\" update=\"false\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </properties>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:1990
+msgid "Then we might have some legacy data association which refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr ""
+
+#: index.docbook:1995
+msgid ""
+ "<![CDATA[<many-to-one name=\"person\"\n"
+ " class=\"Person\" property-ref=\"name\">\n"
+ " <column name=\"firstName\"/>\n"
+ " <column name=\"initial\"/>\n"
+ " <column name=\"lastName\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:1997
+msgid "We don't recommend the use of this kind of thing outside the context of mapping legacy data."
+msgstr ""
+
+#: index.docbook:2005
+msgid "subclass"
+msgstr ""
+
+#: index.docbook:2007
+msgid "Finally, polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used."
+msgstr ""
+
+#: index.docbook:2020
+msgid ""
+ "<![CDATA[<subclass\n"
+ " name=\"ClassName\"\n"
+ " discriminator-value=\"discriminator_value\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " extends=\"SuperclassName\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</subclass>]]>"
+msgstr ""
+
+#: index.docbook:2023, index.docbook:2081, index.docbook:2144
+msgid "<literal>name</literal>: The fully qualified class name of the subclass."
+msgstr ""
+
+#: index.docbook:2028
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): A value that distiguishes individual subclasses."
+msgstr ""
+
+#: index.docbook:2034, index.docbook:2091, index.docbook:2154
+msgid "<literal>proxy</literal> (optional): Specifies a class or interface to use for lazy initializing proxies."
+msgstr ""
+
+#: index.docbook:2040, index.docbook:2097, index.docbook:2160
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): Setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr ""
+
+#: index.docbook:2048
+msgid "Each subclass should declare its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a heirarchy must define a unique <literal>discriminator-value</literal>. If none is specified, the fully qualified Java class name is used."
+msgstr ""
+
+#: index.docbook:2056, index.docbook:2114, index.docbook:2172
+msgid "For information about inheritance mappings, see <xref linkend=\"inheritance\"/>."
+msgstr ""
+
+#: index.docbook:2063
+msgid "joined-subclass"
+msgstr ""
+
+#: index.docbook:2065
+msgid "Alternatively, each subclass may be mapped to its own table (table-per-subclass mapping strategy). Inherited state is retrieved by joining with the table of the superclass. We use the <literal><joined-subclass></literal> element."
+msgstr ""
+
+#: index.docbook:2078
+msgid ""
+ "<![CDATA[<joined-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <key .... >\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</joined-subclass>]]>"
+msgstr ""
+
+#: index.docbook:2086, index.docbook:2149
+msgid "<literal>table</literal>: The name of the subclass table."
+msgstr ""
+
+#: index.docbook:2105
+msgid "No discriminator column is required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would be re-written as:"
+msgstr ""
+
+#: index.docbook:2112
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class name=\"Cat\" table=\"CATS\">\n"
+ " <id name=\"id\" column=\"uid\" type=\"long\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " <property name=\"birthdate\" type=\"date\"/>\n"
+ " <property name=\"color\" not-null=\"true\"/>\n"
+ " <property name=\"sex\" not-null=\"true\"/>\n"
+ " <property name=\"weight\"/>\n"
+ " <many-to-one name=\"mate\"/>\n"
+ " <set name=\"kittens\">\n"
+ " <key column=\"MOTHER\"/>\n"
+ " <one-to-many class=\"Cat\"/>\n"
+ " </set>\n"
+ " <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
+ " <key column=\"CAT\"/>\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </joined-subclass>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"eg.Dog\">\n"
+ " <!-- mapping for Dog could go here -->\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2121
+msgid "union-subclass"
+msgstr ""
+
+#: index.docbook:2123
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables, (the table-per-concrete-class strategy) where each table defines all persistent state of the class, including inherited state. In Hibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. You can simply map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping."
+msgstr ""
+
+#: index.docbook:2141
+msgid ""
+ "<![CDATA[<union-subclass\n"
+ " name=\"ClassName\"\n"
+ " table=\"tablename\"\n"
+ " proxy=\"ProxyInterface\"\n"
+ " lazy=\"true|false\"\n"
+ " dynamic-update=\"true|false\"\n"
+ " dynamic-insert=\"true|false\"\n"
+ " schema=\"schema\"\n"
+ " catalog=\"catalog\"\n"
+ " extends=\"SuperclassName\"\n"
+ " abstract=\"true|false\"\n"
+ " persister=\"ClassName\"\n"
+ " subselect=\"SQL expression\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\">\n"
+ "\n"
+ " <property .... />\n"
+ " .....\n"
+ "</union-subclass>]]>"
+msgstr ""
+
+#: index.docbook:2168
+msgid "No discriminator column or key column is required for this mapping strategy."
+msgstr ""
+
+#: index.docbook:2179
+msgid "join"
+msgstr ""
+
+#: index.docbook:2181
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables, when there's a 1-to-1 relationship between the tables."
+msgstr ""
+
+#: index.docbook:2195
+msgid ""
+ "<![CDATA[<join\n"
+ " table=\"tablename\"\n"
+ " schema=\"owner\"\n"
+ " catalog=\"catalog\"\n"
+ " fetch=\"join|select\"\n"
+ " inverse=\"true|false\"\n"
+ " optional=\"true|false\">\n"
+ "\n"
+ " <key ... />\n"
+ "\n"
+ " <property ... />\n"
+ " ...\n"
+ "</join>]]>"
+msgstr ""
+
+#: index.docbook:2199
+msgid "<literal>table</literal>: The name of the joined table."
+msgstr ""
+
+#: index.docbook:2216
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): If set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses and an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass, which will be issued only if a row turns out to represent an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr ""
+
+#: index.docbook:2229
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will not try to insert or update the properties defined by this join."
+msgstr ""
+
+#: index.docbook:2236
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): If enabled, Hibernate will insert a row only if the properties defined by this join are non-null and will always use an outer join to retrieve the properties."
+msgstr ""
+
+#: index.docbook:2245
+msgid "For example, the address information for a person can be mapped to a separate table (while preserving value type semantics for all properties):"
+msgstr ""
+
+#: index.docbook:2250
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " table=\"PERSON\">\n"
+ "\n"
+ " <id name=\"id\" column=\"PERSON_ID\">...</id>\n"
+ "\n"
+ " <join table=\"ADDRESS\">\n"
+ " <key column=\"ADDRESS_ID\"/>\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </join>\n"
+ " ...]]>"
+msgstr ""
+
+#: index.docbook:2252
+msgid "This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr ""
+
+#: index.docbook:2262
+msgid "<title>key</title>"
+msgstr ""
+
+#: index.docbook:2264
+msgid "We've seen the <literal><key></literal> element crop up a few times now. It appears anywhere the parent mapping element defines a join to a new table, and defines the foreign key in the joined table, that references the primary key of the original table."
+msgstr ""
+
+#: index.docbook:2280
+msgid ""
+ "<![CDATA[<key\n"
+ " column=\"columnname\"\n"
+ " on-delete=\"noaction|cascade\"\n"
+ " property-ref=\"propertyName\"\n"
+ " not-null=\"true|false\"\n"
+ " update=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:2291
+msgid "<literal>on-delete</literal> (optional, defaults to <literal>noaction</literal>): Specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr ""
+
+#: index.docbook:2298
+msgid "<literal>property-ref</literal> (optional): Specifies that the foreign key refers to columns that are not the primary key of the orginal table. (Provided for legacy data.)"
+msgstr ""
+
+#: index.docbook:2305
+msgid "<literal>not-null</literal> (optional): Specifies that the foreign key columns are not nullable (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: index.docbook:2312
+msgid "<literal>update</literal> (optional): Specifies that the foreign key should never be updated (this is implied whenever the foreign key is also part of the primary key)."
+msgstr ""
+
+#: index.docbook:2319
+msgid "<literal>unique</literal> (optional): Specifies that the foreign key should have a unique constraint (this is implied whenever the foreign key is also the primary key)."
+msgstr ""
+
+#: index.docbook:2327
+msgid "We recommend that for systems where delete performance is important, all keys should be defined <literal>on-delete=\"cascade\"</literal>, and Hibernate will use a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr ""
+
+#: index.docbook:2335
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one to many association. If you map a unidirectional one to many to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr ""
+
+#: index.docbook:2345
+msgid "column and formula elements"
+msgstr ""
+
+#: index.docbook:2346
+msgid "Any mapping element which accepts a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute."
+msgstr ""
+
+#: index.docbook:2352
+msgid ""
+ "<![CDATA[<column\n"
+ " name=\"column_name\"\n"
+ " length=\"N\"\n"
+ " precision=\"N\"\n"
+ " scale=\"N\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " unique-key=\"multicolumn_unique_key_name\"\n"
+ " index=\"index_name\"\n"
+ " sql-type=\"sql_type_name\"\n"
+ " check=\"SQL expression\"\n"
+ " default=\"SQL expression\"/>]]>"
+msgstr ""
+
+#: index.docbook:2354
+msgid "<![CDATA[<formula>SQL expression</formula>]]>"
+msgstr ""
+
+#: index.docbook:2356
+msgid "<literal>column</literal> and <literal>formula</literal> attributes may even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr ""
+
+#: index.docbook:2362
+msgid ""
+ "<![CDATA[<many-to-one name=\"homeAddress\" class=\"Address\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"person_id\" not-null=\"true\" length=\"10\"/>\n"
+ " <formula>'MAILING'</formula>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:2367
+msgid "import"
+msgstr ""
+
+#: index.docbook:2369
+msgid "Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified (package) name in Hibernate queries. Classes may be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You may even import classes and interfaces that are not explicitly mapped."
+msgstr ""
+
+#: index.docbook:2376
+msgid "<![CDATA[<import class=\"java.lang.Object\" rename=\"Universe\"/>]]>"
+msgstr ""
+
+#: index.docbook:2383
+msgid ""
+ "<![CDATA[<import\n"
+ " class=\"ClassName\"\n"
+ " rename=\"ShortName\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:2386
+msgid "<literal>class</literal>: The fully qualified class name of of any Java class."
+msgstr ""
+
+#: index.docbook:2391
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): A name that may be used in the query language."
+msgstr ""
+
+#: index.docbook:2402
+msgid "<title>any</title>"
+msgstr ""
+
+#: index.docbook:2404
+msgid "There is one further type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping always requires more than one column. The first column holds the type of the associated entity. The remaining columns hold the identifier. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping (polymorphic) associations. You should use this only in very special cases (eg. audit logs, user session data, etc)."
+msgstr ""
+
+#: index.docbook:2414
+msgid "The <literal>meta-type</literal> attribute lets the application specify a custom type that maps database column values to persistent classes which have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr ""
+
+#: index.docbook:2421
+msgid ""
+ "<![CDATA[<any name=\"being\" id-type=\"long\" meta-type=\"string\">\n"
+ " <meta-value value=\"TBL_ANIMAL\" class=\"Animal\"/>\n"
+ " <meta-value value=\"TBL_HUMAN\" class=\"Human\"/>\n"
+ " <meta-value value=\"TBL_ALIEN\" class=\"Alien\"/>\n"
+ " <column name=\"table_name\"/>\n"
+ " <column name=\"id\"/>\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:2432
+msgid ""
+ "<![CDATA[<any\n"
+ " name=\"propertyName\"\n"
+ " id-type=\"idtypename\"\n"
+ " meta-type=\"metatypename\"\n"
+ " cascade=\"cascade_style\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ ">\n"
+ " <meta-value ... />\n"
+ " <meta-value ... />\n"
+ " .....\n"
+ " <column .... />\n"
+ " <column .... />\n"
+ " .....\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:2435
+msgid "<literal>name</literal>: the property name."
+msgstr ""
+
+#: index.docbook:2440
+msgid "<literal>id-type</literal>: the identifier type."
+msgstr ""
+
+#: index.docbook:2445
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): Any type that is allowed for a discriminator mapping."
+msgstr ""
+
+#: index.docbook:2451
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr ""
+
+#: index.docbook:2463
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, define if a version increment should occur if this property is dirty."
+msgstr ""
+
+#: index.docbook:2478
+msgid "Hibernate Types"
+msgstr ""
+
+#: index.docbook:2481
+msgid "Entities and values"
+msgstr ""
+
+#: index.docbook:2483
+msgid "To understand the behaviour of various Java language-level objects with respect to the persistence service, we need to classify them into two groups:"
+msgstr ""
+
+#: index.docbook:2488
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted (except that saves and deletions may be <emphasis>cascaded</emphasis> from a parent entity to its children). This is different from the ODMG model of object persistence by reachablity - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned."
+msgstr ""
+
+#: index.docbook:2499
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives, collections (not what's inside a collection), components and certain immutable objects. Unlike entities, values (in particular collections and components) <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects (and primitives) are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr ""
+
+#: index.docbook:2510
+msgid "Up until now, we've been using the term \"persistent class\" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities. A <emphasis>component</emphasis> is a user defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, we can say that all types (classes) provided by the JDK have value type semantics in Java, while user-defined types may be mapped with entity or value type semantics. This decision is up to the application developer. A good hint for an entity class in a domain model are shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr ""
+
+#: index.docbook:2524
+msgid "We'll revisit both concepts throughout the documentation."
+msgstr ""
+
+#: index.docbook:2528
+msgid "The challenge is to map the Java type system (and the developers' definition of entities and value types) to the SQL/database type system. The bridge between both systems is provided by Hibernate: for entities we use <literal><class></literal>, <literal><subclass></literal> and so on. For value types we use <literal><property></literal>, <literal><component></literal>, etc, usually with a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides many mappings (for standard JDK value types) out of the box. You can write your own mapping types and implement your custom conversion strategies as well, as you'll see later."
+msgstr ""
+
+#: index.docbook:2541
+msgid "All built-in Hibernate types except collections support null semantics."
+msgstr ""
+
+#: index.docbook:2548
+msgid "Basic value types"
+msgstr ""
+
+#: index.docbook:2550
+msgid "The built-in <emphasis>basic mapping types</emphasis> may be roughly categorized into"
+msgstr ""
+
+#: index.docbook:2555
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr ""
+
+#: index.docbook:2558
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr ""
+
+#: index.docbook:2567
+msgid "string"
+msgstr ""
+
+#: index.docbook:2569
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr ""
+
+#: index.docbook:2576
+msgid "date, time, timestamp"
+msgstr ""
+
+#: index.docbook:2578
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr ""
+
+#: index.docbook:2586
+msgid "calendar, calendar_date"
+msgstr ""
+
+#: index.docbook:2588
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr ""
+
+#: index.docbook:2596
+msgid "big_decimal, big_integer"
+msgstr ""
+
+#: index.docbook:2598
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr ""
+
+#: index.docbook:2606
+msgid "locale, timezone, currency"
+msgstr ""
+
+#: index.docbook:2608
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr ""
+
+#: index.docbook:2620
+msgid "<literal>class</literal>"
+msgstr ""
+
+#: index.docbook:2622
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr ""
+
+#: index.docbook:2630
+msgid "binary"
+msgstr ""
+
+#: index.docbook:2632
+msgid "Maps byte arrays to an appropriate SQL binary type."
+msgstr ""
+
+#: index.docbook:2638
+msgid "text"
+msgstr ""
+
+#: index.docbook:2640
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr ""
+
+#: index.docbook:2647
+msgid "serializable"
+msgstr ""
+
+#: index.docbook:2649
+msgid "Maps serializable Java types to an appropriate SQL binary type. You may also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr ""
+
+#: index.docbook:2658
+msgid "clob, blob"
+msgstr ""
+
+#: index.docbook:2660
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types may be inconvenient for some applications, since the blob or clob object may not be reused outside of a transaction. (Furthermore, driver support is patchy and inconsistent.)"
+msgstr ""
+
+#: index.docbook:2670
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr ""
+
+#: index.docbook:2674
+msgid "Type mappings for what are usually considered mutable Java types, where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new (nonidentical) object to the property."
+msgstr ""
+
+#: index.docbook:2689
+msgid "Unique identifiers of entities and collections may be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. (Composite identifiers are also allowed, see below.)"
+msgstr ""
+
+#: index.docbook:2695
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr ""
+
+#: index.docbook:2704
+msgid "Custom value types"
+msgstr ""
+
+#: index.docbook:2706
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. But custom types are not limited to mapping a property (or collection element) to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr ""
+
+#: index.docbook:2717
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. Check out <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr ""
+
+#: index.docbook:2725
+msgid ""
+ "<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
+ " <column name=\"first_string\"/>\n"
+ " <column name=\"second_string\"/>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2727
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr ""
+
+#: index.docbook:2732
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr ""
+
+#: index.docbook:2738
+msgid "You may even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr ""
+
+#: index.docbook:2746
+msgid ""
+ "<![CDATA[<property name=\"priority\">\n"
+ " <type name=\"com.mycompany.usertypes.DefaultValueIntegerType\">\n"
+ " <param name=\"default\">0</param>\n"
+ " </type>\n"
+ "</property>]]>"
+msgstr ""
+
+#: index.docbook:2748
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr ""
+
+#: index.docbook:2753
+msgid "If you use a certain <literal>UserType</literal> very often, it may be useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and may also contain a list of default parameter values if the type is parameterized."
+msgstr ""
+
+#: index.docbook:2760
+msgid ""
+ "<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
+ " <param name=\"default\">0</param>\n"
+ "</typedef>]]>"
+msgstr ""
+
+#: index.docbook:2762
+msgid "<![CDATA[<property name=\"priority\" type=\"default_zero\"/>]]>"
+msgstr ""
+
+#: index.docbook:2764
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr ""
+
+#: index.docbook:2769
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will very rarely <emphasis>need</emphasis> to use a custom type, it is nevertheless considered good form to use custom types for (non-entity) classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could easily be mapped as a component. One motivation for this is abstraction. With a custom type, your mapping documents would be future-proofed against possible changes in your way of representing monetary values."
+msgstr ""
+
+#: index.docbook:2785
+msgid "Mapping a class more than once"
+msgstr ""
+
+#: index.docbook:2786
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case you must specify an <emphasis>entity name</emphasis> do disambiguate between instances of the two mapped entities. (By default, the entity name is the same as the class name.) Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr ""
+
+#: index.docbook:2794
+msgid ""
+ "<![CDATA[<class name=\"Contract\" table=\"Contracts\"\n"
+ " entity-name=\"CurrentContract\">\n"
+ " ...\n"
+ " <set name=\"history\" inverse=\"true\"\n"
+ " order-by=\"effectiveEndDate desc\">\n"
+ " <key column=\"currentContractId\"/>\n"
+ " <one-to-many entity-name=\"HistoricalContract\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Contract\" table=\"ContractHistory\"\n"
+ " entity-name=\"HistoricalContract\">\n"
+ " ...\n"
+ " <many-to-one name=\"currentContract\"\n"
+ " column=\"currentContractId\"\n"
+ " entity-name=\"CurrentContract\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2796
+msgid "Notice how associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:2804
+msgid "SQL quoted identifiers"
+msgstr ""
+
+#: index.docbook:2805
+msgid "You may force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal> (usually double quotes, but brackets for SQL Server and backticks for MySQL)."
+msgstr ""
+
+#: index.docbook:2812
+msgid ""
+ "<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
+ " <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
+ " <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:2818
+msgid "Metadata alternatives"
+msgstr ""
+
+#: index.docbook:2820
+msgid "XML isn't for everyone, and so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr ""
+
+#: index.docbook:2825
+msgid "Using XDoclet markup"
+msgstr ""
+
+#: index.docbook:2827
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We will not cover this approach in this document, since strictly it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings."
+msgstr ""
+
+#: index.docbook:2834
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "/**\n"
+ " * @hibernate.class\n"
+ " * table=\"CATS\"\n"
+ " */\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ " private Date birthdate;\n"
+ " private Cat mother;\n"
+ " private Set kittens\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ "\n"
+ " /*\n"
+ " * @hibernate.id\n"
+ " * generator-class=\"native\"\n"
+ " * column=\"CAT_ID\"\n"
+ " */\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.many-to-one\n"
+ " * column=\"PARENT_ID\"\n"
+ " */\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"BIRTH_DATE\"\n"
+ " */\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"WEIGHT\"\n"
+ " */\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"COLOR\"\n"
+ " * not-null=\"true\"\n"
+ " */\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ " /**\n"
+ " * @hibernate.set\n"
+ " * inverse=\"true\"\n"
+ " * order-by=\"BIRTH_DATE\"\n"
+ " * @hibernate.collection-key\n"
+ " * column=\"PARENT_ID\"\n"
+ " * @hibernate.collection-one-to-many\n"
+ " */\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "\n"
+ " /**\n"
+ " * @hibernate.property\n"
+ " * column=\"SEX\"\n"
+ " * not-null=\"true\"\n"
+ " * update=\"false\"\n"
+ " */\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2836
+msgid "See the Hibernate web site for more examples of XDoclet and Hibernate."
+msgstr ""
+
+#: index.docbook:2843
+msgid "Using JDK 5.0 Annotations"
+msgstr ""
+
+#: index.docbook:2845
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level, type-safe and checked at compile time. This mechnism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API), support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package, as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr ""
+
+#: index.docbook:2856
+msgid "This is an example of a POJO class annotated as an EJB entity bean:"
+msgstr ""
+
+#: index.docbook:2860
+msgid ""
+ "<![CDATA[@Entity(access = AccessType.FIELD)\n"
+ "public class Customer implements Serializable {\n"
+ "\n"
+ " @Id;\n"
+ " Long id;\n"
+ "\n"
+ " String firstName;\n"
+ " String lastName;\n"
+ " Date birthday;\n"
+ "\n"
+ " @Transient\n"
+ " Integer age;\n"
+ "\n"
+ " @Embedded\n"
+ " private Address homeAddress;\n"
+ "\n"
+ " @OneToMany(cascade=CascadeType.ALL)\n"
+ " @JoinColumn(name=\"CUSTOMER_ID\")\n"
+ " Set<Order> orders;\n"
+ "\n"
+ " // Getter/setter and business methods\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:2862
+msgid "Note that support for JDK 5.0 Annotations (and JSR-220) is still work in progress and not completed. Please refer to the Hibernate Annotations module for more details."
+msgstr ""
+
+#: index.docbook:2871
+msgid "Generated Properties"
+msgstr ""
+
+#: index.docbook:2872
+msgid "Generated properties are properties which have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects which contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. Essentially, whenever Hibernate issues an SQL INSERT or UPDATE for an entity which has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr ""
+
+#: index.docbook:2881
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>versions, <xref linkend=\"mapping-declaration-timestamp\"/>timestamps, and <xref linkend=\"mapping-declaration-property\"/>simple properties can be marked as generated."
+msgstr ""
+
+#: index.docbook:2888
+msgid "<literal>never</literal> (the default) - means that the given property value is not generated within the database."
+msgstr ""
+
+#: index.docbook:2892
+msgid "<literal>insert</literal> - states that the given property value is generated on insert, but is not regenerated on subsequent updates. Things like created-date would fall into this category. Note that even thought <xref linkend=\"mapping-declaration-version\"/>version and <xref linkend=\"mapping-declaration-timestamp\"/>timestamp properties can be marked as generated, this option is not available there..."
+msgstr ""
+
+#: index.docbook:2900
+msgid "<literal>always</literal> - states that the property value is generated both on insert and on update."
+msgstr ""
+
+#: index.docbook:2907
+msgid "Auxiliary Database Objects"
+msgstr ""
+
+#: index.docbook:2908
+msgid "Allows CREATE and DROP of arbitrary database objects, in conjunction with Hibernate's schema evolution tools, to provide the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, really any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid here (ALTERs, INSERTS, etc). There are essentially two modes for defining auxiliary database objects..."
+msgstr ""
+
+#: index.docbook:2917
+msgid "The first mode is to explicitly list the CREATE and DROP commands out in the mapping file:"
+msgstr ""
+
+#: index.docbook:2921
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <create>CREATE TRIGGER my_trigger ...</create>\n"
+ " <drop>DROP TRIGGER my_trigger</drop>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2922
+msgid "The second mode is to supply a custom class which knows how to construct the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr ""
+
+#: index.docbook:2927
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:2928
+msgid "Additionally, these database objects can be optionally scoped such that they only apply when certain dialects are used."
+msgstr ""
+
+#: index.docbook:2932
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " ...\n"
+ " <database-object>\n"
+ " <definition class=\"MyTriggerDefinition\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
+ " <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
+ " </database-object>\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/batch.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/batch.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/batch.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,281 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Batch processing"
+msgstr ""
+
+#: index.docbook:7
+msgid "A naive approach to inserting 100 000 rows in the database using Hibernate might look like this:"
+msgstr ""
+
+#: index.docbook:12
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ "}\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:14
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50 000th row. That's because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache."
+msgstr ""
+
+#: index.docbook:20
+msgid "In this chapter we'll show you how to avoid this problem. First, however, if you are doing batch processing, it is absolutely critical that you enable the use of JDBC batching, if you intend to achieve reasonable performance. Set the JDBC batch size to a reasonable number (say, 10-50):"
+msgstr ""
+
+#: index.docbook:27
+msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
+msgstr ""
+
+#: index.docbook:29
+msgid "Note that Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identiy</literal> identifier generator."
+msgstr ""
+
+#: index.docbook:34
+msgid "You also might like to do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr ""
+
+#: index.docbook:39
+msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
+msgstr ""
+
+#: index.docbook:41
+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 ""
+
+#: index.docbook:47
+msgid "Batch inserts"
+msgstr ""
+
+#: index.docbook:49
+msgid "When making new objects persistent, you must <literal>flush()</literal> and then <literal>clear()</literal> the session regularly, to control the size of the first-level cache."
+msgstr ""
+
+#: index.docbook:55
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "for ( int i=0; i<100000; i++ ) {\n"
+ " Customer customer = new Customer(.....);\n"
+ " session.save(customer);\n"
+ " if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+ " //flush a batch of inserts and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:60
+msgid "Batch updates"
+msgstr ""
+
+#: index.docbook:62
+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 ""
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .setCacheMode(CacheMode.IGNORE)\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "int count=0;\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " if ( ++count % 20 == 0 ) {\n"
+ " //flush a batch of updates and release memory:\n"
+ " session.flush();\n"
+ " session.clear();\n"
+ " }\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "The StatelessSession interface"
+msgstr ""
+
+#: index.docbook:74
+msgid "Alternatively, Hibernate provides a command-oriented API that may 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 do not ever cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache. A stateless session is a lower-level abstraction, much closer to the underlying JDBC."
+msgstr ""
+
+#: index.docbook:89
+msgid ""
+ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ " \n"
+ "ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
+ " .scroll(ScrollMode.FORWARD_ONLY);\n"
+ "while ( customers.next() ) {\n"
+ " Customer customer = (Customer) customers.get(0);\n"
+ " customer.updateStuff(...);\n"
+ " session.update(customer);\n"
+ "}\n"
+ " \n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:91
+msgid "Note that 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 ""
+
+#: index.docbook:97
+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, which result in immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. Thus, they have very different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr ""
+
+#: index.docbook:110
+msgid "DML-style operations"
+msgstr ""
+
+#: index.docbook:112
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of object state. This implies that the object state is available in memory, hence manipulating (using the SQL <literal>Data Manipulation Language</literal> (DML) statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) data directly in the database will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution which are performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>HQL)."
+msgstr ""
+
+#: index.docbook:122
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>. Some points to note:"
+msgstr ""
+
+#: index.docbook:130
+msgid "In the from-clause, the FROM keyword is optional"
+msgstr ""
+
+#: index.docbook:135
+msgid "There can only be a single entity named in the from-clause; it can optionally 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 ""
+
+#: index.docbook:143
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>joins (either implicit or explicit) can be specified in a bulk HQL query. Sub-queries may be used in the where-clause; the subqueries, themselves, may contain joins."
+msgstr ""
+
+#: index.docbook:150
+msgid "The where-clause is also optional."
+msgstr ""
+
+#: index.docbook:156
+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 ""
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+ "// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:164
+msgid "HQL <literal>UPDATE</literal> statements, by default do not effect the <xref linkend=\"mapping-declaration-version\"/>version or the <xref linkend=\"mapping-declaration-timestamp\"/>timestamp property values for the affected entities; this is in keeping with the EJB3 specification. However, you can force Hibernate to properly 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 ""
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
+ "int updatedEntities = s.createQuery( hqlUpdate )\n"
+ " .setString( \"newName\", newName )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:176
+msgid "Note that custom version types (<literal>org.hibernate.usertype.UserVersionType</literal>) are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr ""
+
+#: index.docbook:181
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
+ "// or String hqlDelete = \"delete Customer where name = :oldName\";\n"
+ "int deletedEntities = s.createQuery( hqlDelete )\n"
+ " .setString( \"oldName\", oldName )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicate the number of entities effected by the operation. Consider 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 inheritence hierarchy."
+msgstr ""
+
+#: index.docbook:199
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr ""
+
+#: index.docbook:207
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr ""
+
+#: index.docbook:210
+msgid "The properties_list is analogous to the <literal>column speficiation</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritence, 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 ""
+
+#: index.docbook:220
+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. Note however that this might 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 ""
+
+#: index.docbook:232
+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 later 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. Note that for the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementors 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 ""
+
+#: index.docbook:247
+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 ""
+
+#: index.docbook:257
+msgid "An example HQL <literal>INSERT</literal> statement execution:"
+msgstr ""
+
+#: index.docbook:261
+msgid ""
+ "<![CDATA[Session session = sessionFactory.openSession();\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
+ "int createdEntities = s.createQuery( hqlInsert )\n"
+ " .executeUpdate();\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/best_practices.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/best_practices.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/best_practices.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,168 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Best Practices"
+msgstr ""
+
+#: index.docbook:9
+msgid "Write fine-grained classes and map them using <literal><component></literal>."
+msgstr ""
+
+#: index.docbook:11
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr ""
+
+#: index.docbook:19
+msgid "Declare identifier properties on persistent classes."
+msgstr ""
+
+#: index.docbook:21
+msgid "Hibernate makes identifier properties optional. There are all sorts of reasons why you should use them. We recommend that identifiers be 'synthetic' (generated, with no business meaning)."
+msgstr ""
+
+#: index.docbook:29
+msgid "Identify natural keys."
+msgstr ""
+
+#: index.docbook:31
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr ""
+
+#: index.docbook:39
+msgid "Place each class mapping in its own file."
+msgstr ""
+
+#: index.docbook:41
+msgid "Don't use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes particularly good sense in a team environment."
+msgstr ""
+
+#: index.docbook:49
+msgid "Load mappings as resources."
+msgstr ""
+
+#: index.docbook:51
+msgid "Deploy the mappings along with the classes they map."
+msgstr ""
+
+#: index.docbook:57
+msgid "Consider externalising query strings."
+msgstr ""
+
+#: index.docbook:59
+msgid "This is a good practice if your queries call non-ANSI-standard SQL functions. Externalising the query strings to mapping files will make the application more portable."
+msgstr ""
+
+#: index.docbook:67
+msgid "Use bind variables."
+msgstr ""
+
+#: index.docbook:69
+msgid "As in JDBC, always replace non-constant values by \"?\". Never use string manipulation to bind a non-constant value in a query! Even better, consider using named parameters in queries."
+msgstr ""
+
+#: index.docbook:77
+msgid "Don't manage your own JDBC connections."
+msgstr ""
+
+#: index.docbook:79
+msgid "Hibernate lets the application manage JDBC connections. This approach should be considered a last-resort. If you can't use the built-in connections providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr ""
+
+#: index.docbook:87
+msgid "Consider using a custom type."
+msgstr ""
+
+#: index.docbook:89
+msgid "Suppose you have a Java type, say from some library, that needs to be persisted but doesn't provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to / from a Hibernate type."
+msgstr ""
+
+#: index.docbook:98
+msgid "Use hand-coded JDBC in bottlenecks."
+msgstr ""
+
+#: index.docbook:100
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. But please, wait until you <emphasis>know</emphasis> something is a bottleneck. And don't assume that direct JDBC is necessarily faster. If you need to use direct JDBC, it might be worth opening a Hibernate <literal>Session</literal> and using that JDBC connection. That way you can still use the same transaction strategy and underlying connection provider."
+msgstr ""
+
+#: index.docbook:110
+msgid "Understand <literal>Session</literal> flushing."
+msgstr ""
+
+#: index.docbook:112
+msgid "From time to time the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You may sometimes minimize unnecessary flushing by disabling automatic flushing or even by changing the order of queries and other operations within a particular transaction."
+msgstr ""
+
+#: index.docbook:121
+msgid "In a three tiered architecture, consider using detached objects."
+msgstr ""
+
+#: index.docbook:123
+msgid "When using a servlet / session bean architecture, you could pass persistent objects loaded in the session bean to and from the servlet / JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr ""
+
+#: index.docbook:132
+msgid "In a two tiered architecture, consider using long persistence contexts."
+msgstr ""
+
+#: index.docbook:134
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often neccessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An alternative, extremely appropriate in two tiered architecture, is to maintain a single open persistence contact (session) for the whole life cycle of the application transaction and simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction, or you will be working with stale data."
+msgstr ""
+
+#: index.docbook:148
+msgid "Don't treat exceptions as recoverable."
+msgstr ""
+
+#: index.docbook:150
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you don't, Hibernate can't guarantee that in-memory state accurately represents persistent state. As a special case of this, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr ""
+
+#: index.docbook:160
+msgid "Prefer lazy fetching for associations."
+msgstr ""
+
+#: index.docbook:162
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When an join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr ""
+
+#: index.docbook:172
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data."
+msgstr ""
+
+#: index.docbook:177
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. However, you will still need an assembly phase (think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects) unless you are prepared to hold the persistence context (the session) open across the view rendering process. This is not a limitation of Hibernate! It is a fundamental requirement of safe transactional data access."
+msgstr ""
+
+#: index.docbook:191
+msgid "Consider abstracting your business logic from Hibernate."
+msgstr ""
+
+#: index.docbook:193
+msgid "Hide (Hibernate) data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC, associated to Hibernate via a <literal>UserType</literal>. (This advice is intended for \"sufficiently large\" applications; it is not appropriate for an application with five tables!)"
+msgstr ""
+
+#: index.docbook:203
+msgid "Don't use exotic association mappings."
+msgstr ""
+
+#: index.docbook:205
+msgid "Good usecases for a real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, we think that most associations are one-to-many and many-to-one, you should be careful when using any other association style and ask yourself if it is really neccessary."
+msgstr ""
+
+#: index.docbook:215
+msgid "Prefer bidirectional associations."
+msgstr ""
+
+#: index.docbook:217
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/collection_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/collection_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/collection_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,919 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Collection Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "Persistent collections"
+msgstr ""
+
+#: index.docbook:10
+msgid "Hibernate requires that persistent collection-valued fields be declared as an interface type, for example:"
+msgstr ""
+
+#: index.docbook:15
+msgid ""
+ "<![CDATA[public class Product {\n"
+ " private String serialNumber;\n"
+ " private Set parts = new HashSet();\n"
+ " \n"
+ " public Set getParts() { return parts; }\n"
+ " void setParts(Set parts) { this.parts = parts; }\n"
+ " public String getSerialNumber() { return serialNumber; }\n"
+ " void setSerialNumber(String sn) { serialNumber = sn; }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:17
+msgid "The actual interface might be <literal>java.util.Set</literal>, <literal>java.util.Collection</literal>, <literal>java.util.List</literal>, <literal>java.util.Map</literal>, <literal>java.util.SortedSet</literal>, <literal>java.util.SortedMap</literal> or ... anything you like! (Where \"anything you like\" means you will have to write an implementation of <literal>org.hibernate.usertype.UserCollectionType</literal>.)"
+msgstr ""
+
+#: index.docbook:26
+msgid "Notice how we initialized the instance variable with an instance of <literal>HashSet</literal>. This is the best way to initialize collection valued properties of newly instantiated (non-persistent) instances. When you make the instance persistent - by calling <literal>persist()</literal>, for example - Hibernate will actually replace the <literal>HashSet</literal> with an instance of Hibernate's own implementation of <literal>Set</literal>. Watch out for errors like this:"
+msgstr ""
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "Cat kitten = new DomesticCat();\n"
+ "....\n"
+ "Set kittens = new HashSet();\n"
+ "kittens.add(kitten);\n"
+ "cat.setKittens(kittens);\n"
+ "session.persist(cat);\n"
+ "kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
+ "(HashSet) cat.getKittens(); // Error!]]>"
+msgstr ""
+
+#: index.docbook:38
+msgid "The persistent collections injected by Hibernate behave like <literal>HashMap</literal>, <literal>HashSet</literal>, <literal>TreeMap</literal>, <literal>TreeSet</literal> or <literal>ArrayList</literal>, depending upon the interface type."
+msgstr ""
+
+#: index.docbook:45
+msgid "Collections instances have the usual behavior of value types. They are automatically persisted when referenced by a persistent object and automatically deleted when unreferenced. If a collection is passed from one persistent object to another, its elements might be moved from one table to another. Two entities may not share a reference to the same collection instance. Due to the underlying relational model, collection-valued properties do not support null value semantics; Hibernate does not distinguish between a null collection reference and an empty collection."
+msgstr ""
+
+#: index.docbook:56
+msgid "You shouldn't have to worry much about any of this. Use persistent collections the same way you use ordinary Java collections. Just make sure you understand the semantics of bidirectional associations (discussed later)."
+msgstr ""
+
+#: index.docbook:65
+msgid "Collection mappings"
+msgstr ""
+
+#: index.docbook:67
+msgid "The Hibernate mapping element used for mapping a collection depends upon the type of the interface. For example, a <literal><set></literal> element is used for mapping properties of type <literal>Set</literal>."
+msgstr ""
+
+#: index.docbook:73
+msgid ""
+ "<![CDATA[<class name=\"Product\">\n"
+ " <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
+ " <set name=\"parts\">\n"
+ " <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:75
+msgid "Apart from <literal><set></literal>, there is also <literal><list></literal>, <literal><map></literal>, <literal><bag></literal>, <literal><array></literal> and <literal><primitive-array></literal> mapping elements. The <literal><map></literal> element is representative:"
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<map\n"
+ " name=\"propertyName\"\n"
+ " table=\"table_name\"\n"
+ " schema=\"schema_name\"\n"
+ " lazy=\"true|extra|false\"\n"
+ " inverse=\"true|false\"\n"
+ " cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
+ " sort=\"unsorted|natural|comparatorClass\"\n"
+ " order-by=\"column_name asc|desc\"\n"
+ " where=\"arbitrary sql where condition\"\n"
+ " fetch=\"join|select|subselect\"\n"
+ " batch-size=\"N\"\n"
+ " access=\"field|property|ClassName\"\n"
+ " optimistic-lock=\"true|false\"\n"
+ " mutable=\"true|false\"\n"
+ " node=\"element-name|.\"\n"
+ " embed-xml=\"true|false\"\n"
+ ">\n"
+ "\n"
+ " <key .... />\n"
+ " <map-key .... />\n"
+ " <element .... />\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid "<literal>name</literal> the collection property name"
+msgstr ""
+
+#: index.docbook:108
+msgid "<literal>table</literal> (optional - defaults to property name) the name of the collection table (not used for one-to-many associations)"
+msgstr ""
+
+#: index.docbook:114
+msgid "<literal>schema</literal> (optional) the name of a table schema to override the schema declared on the root element"
+msgstr ""
+
+#: index.docbook:120
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>) may be used to disable lazy fetching and specify that the association is always eagerly fetched, or to enable \"extra-lazy\" fetching where most operations do not initialize the collection (suitable for very large collections)"
+msgstr ""
+
+#: index.docbook:129
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>) mark this collection as the \"inverse\" end of a bidirectional association"
+msgstr ""
+
+#: index.docbook:135
+msgid "<literal>cascade</literal> (optional - defaults to <literal>none</literal>) enable operations to cascade to child entities"
+msgstr ""
+
+#: index.docbook:141
+msgid "<literal>sort</literal> (optional) specify a sorted collection with <literal>natural</literal> sort order, or a given comparator class"
+msgstr ""
+
+#: index.docbook:147
+msgid "<literal>order-by</literal> (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the <literal>Map</literal>, <literal>Set</literal> or bag, together with an optional <literal>asc</literal> or <literal>desc</literal>"
+msgstr ""
+
+#: index.docbook:154
+msgid "<literal>where</literal> (optional) specify an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving or removing the collection (useful if the collection should contain only a subset of the available data)"
+msgstr ""
+
+#: index.docbook:161
+msgid "<literal>fetch</literal> (optional, defaults to <literal>select</literal>) Choose between outer-join fetching, fetching by sequential select, and fetching by sequential subselect."
+msgstr ""
+
+#: index.docbook:168
+msgid "<literal>batch-size</literal> (optional, defaults to <literal>1</literal>) specify a \"batch size\" for lazily fetching instances of this collection."
+msgstr ""
+
+#: index.docbook:174
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): The strategy Hibernate should use for accessing the collection property value."
+msgstr ""
+
+#: index.docbook:180
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): Species that changes to the state of the collection results in increment of the owning entity's version. (For one to many associations, it is often reasonable to disable this setting.)"
+msgstr ""
+
+#: index.docbook:188
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): A value of <literal>false</literal> specifies that the elements of the collection never change (a minor performance optimization in some cases)."
+msgstr ""
+
+#: index.docbook:198
+msgid "Collection foreign keys"
+msgstr ""
+
+#: index.docbook:200
+msgid "Collection instances are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the <emphasis>collection key column</emphasis> (or columns) of the collection table. The collection key column is mapped by the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:208
+msgid "There may be a nullability constraint on the foreign key column. For most collections, this is implied. For unidirectional one to many associations, the foreign key column is nullable by default, so you might need to specify <literal>not-null=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:215
+msgid "<![CDATA[<key column=\"productSerialNumber\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:217
+msgid "The foreign key constraint may use <literal>ON DELETE CASCADE</literal>."
+msgstr ""
+
+#: index.docbook:221
+msgid "<![CDATA[<key column=\"productSerialNumber\" on-delete=\"cascade\"/>]]>"
+msgstr ""
+
+#: index.docbook:223
+msgid "See the previous chapter for a full definition of the <literal><key></literal> element."
+msgstr ""
+
+#: index.docbook:231
+msgid "Collection elements"
+msgstr ""
+
+#: index.docbook:233
+msgid "Collections may contain almost any other Hibernate type, including all basic types, custom types, components, and of course, references to other entities. This is an important distinction: an object in a collection might be handled with \"value\" semantics (its life cycle fully depends on the collection owner) or it might be a reference to another entity, with its own life cycle. In the latter case, only the \"link\" between the two objects is considered to be state held by the collection."
+msgstr ""
+
+#: index.docbook:242
+msgid "The contained type is referred to as the <emphasis>collection element type</emphasis>. Collection elements are mapped by <literal><element></literal> or <literal><composite-element></literal>, or in the case of entity references, with <literal><one-to-many></literal> or <literal><many-to-many></literal>. The first two map elements with value semantics, the next two are used to map entity associations."
+msgstr ""
+
+#: index.docbook:254
+msgid "Indexed collections"
+msgstr ""
+
+#: index.docbook:256
+msgid "All collection mappings, except those with set and bag semantics, need an <emphasis>index column</emphasis> in the collection table - a column that maps to an array index, or <literal>List</literal> index, or <literal>Map</literal> key. The index of a <literal>Map</literal> may be of any basic type, mapped with <literal><map-key></literal>, it may be an entity reference mapped with <literal><map-key-many-to-many></literal>, or it may be a composite type, mapped with <literal><composite-map-key></literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal><list-index></literal> element. The mapped column contains sequential integers (numbered from zero, by default)."
+msgstr ""
+
+#: index.docbook:267
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"index1\" coords=\"2 45\"/> <area id=\"index2\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<list-index \n"
+ " column=\"column_name\"\n"
+ " base=\"0|1|...\"/>]]></programlisting> <calloutlist> <callout arearefs=\"index1\"> <para> <literal>column_name</literal> (required): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (optional, defaults to <literal>0</literal>): The value of the index column that corresponds to the first element of the list or array. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"mapkey1\" coords=\"2 45\"/> <area id=\"mapkey2\" coords=\"3 45\"/> <area id=\"mapkey3\" coords=\"4 45\"/> </areaspec> <programlisting><![CDATA[<map-key \n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"type_name\"\n"
+ " node=\"@attribute-name\"\n"
+ " length=\"N\"/>]]></programlisting> <calloutlist> <callout arearefs=\"mapkey1\"> <para> <literal>column</literal> (optional): The name of the column holding the collection index values. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the key of the map. </para> </callout> <callout arearefs=\"mapkey3\"> <para> <literal>type</literal> (reguired): The type of the map keys. </para> </callout> </calloutlist> </programlistingco> <programlistingco> <areaspec> <area id=\"indexmanytomany1\" coords=\"2 45\"/> <area id=\"indexmanytomany2\" coords=\"3 45\"/> <area id=\"indexmanytomany3\" coords=\"3 45\"/> </areaspec> <programlisting><![CDATA[<map-key-many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"indexmanytomany1\"> <para> <literal>column</literal> (optional): The name of the foreign key column for the collection index values. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (optional): A SQL formula used to evaluate the foreign key of the map key. </para> </callout> <callout arearefs=\"indexmanytomany3\"> <para> <literal>class</literal> (required): The entity class used as the map key. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+
+#: index.docbook:348
+msgid "If your table doesn't have an index column, and you still wish to use <literal>List</literal> as the property type, you should map the property as a Hibernate <emphasis><bag></emphasis>. A bag does not retain its order when it is retrieved from the database, but it may be optionally sorted or ordered."
+msgstr ""
+
+#: index.docbook:357
+msgid "There are quite a range of mappings that can be generated for collections, covering many common relational models. We suggest you experiment with the schema generation tool to get a feeling for how various mapping declarations translate to database tables."
+msgstr ""
+
+#: index.docbook:364
+msgid "Collections of values and many-to-many associations"
+msgstr ""
+
+#: index.docbook:366
+msgid "Any collection of values or many-to-many association requires a dedicated <emphasis>collection table</emphasis> with a foreign key column or columns, <emphasis>collection element column</emphasis> or columns and possibly an index column or columns."
+msgstr ""
+
+#: index.docbook:373
+msgid "For a collection of values, we use the <literal><element></literal> tag."
+msgstr ""
+
+#: index.docbook:375
+msgid ""
+ "<programlistingco> <areaspec> <area id=\"element1b\" coords=\"2 50\"/> <area id=\"element2b\" coords=\"3 50\"/> <area id=\"element3b\" coords=\"4 50\"/> </areaspec> <programlisting><![CDATA[<element\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " type=\"typename\"\n"
+ " length=\"L\"\n"
+ " precision=\"P\"\n"
+ " scale=\"S\"\n"
+ " not-null=\"true|false\"\n"
+ " unique=\"true|false\"\n"
+ " node=\"element-name\"\n"
+ "/>]]></programlisting> <calloutlist> <callout arearefs=\"element1b\"> <para> <literal>column</literal> (optional): The name of the column holding the collection element values. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (required): The type of the collection element. </para> </callout> </calloutlist> </programlistingco> <para> A <emphasis>many-to-many association</emphasis> is specified using the <literal><many-to-many></literal> element. </para> <programlistingco> <areaspec> <area id=\"manytomany1\" coords=\"2 60\"/> <area id=\"manytomany2\" coords=\"3 60\"/> <area id=\"manytomany3\" coords=\"4 60\"/> <area id=\"manytomany4\" coords=\"5 60\"/> <area id=\"manytomany5\" coords=\"6 60\"/> <area id=\"manytomany6\" coords=\"7 60\"/> <area id=\"manytomany7\" coords=\"8 60\"/> <area id=\!
"manytomany8\" coords=\"9 60\"/> </areaspec> <programlisting><![CDATA[<many-to-many\n"
+ " column=\"column_name\"\n"
+ " formula=\"any SQL expression\"\n"
+ " class=\"ClassName\"\n"
+ " fetch=\"select|join\"\n"
+ " unique=\"true|false\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " property-ref=\"propertyNameFromAssociatedClass\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]></programlisting> <calloutlist> <callout arearefs=\"manytomany1\"> <para> <literal>column</literal> (optional): The name of the element foreign key column. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (optional): An SQL formula used to evaluate the element foreign key value. </para> </callout> <callout arearefs=\"manytomany3\"> <para> <literal>class</literal> (required): The name of the associated class. </para> </callout> <callout arearefs=\"manytomany4\"> <para> <literal>fetch</literal> (optional - defaults to <literal>join</literal>): enables outer-join or sequential select fetching for this association. This is a special case; for full eager fetching (in a single <literal>SELECT</literal>) of an entity and its many-to-many relationships to other entities, you would enable <literal>join</literal> fetching not only of the collection itself, but also with this attribute on the <literal><many-to-many></literal!
> nested element. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (optional): Enable the DDL generation of a unique constraint for the foreign-key column. This makes the association multiplicity effectively one to many. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how foreign keys that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association. </para> </callout> <callout arearefs=\"manytomany7\"> <para> <literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>. </para> </callout> <callout arearefs=\"manytomany8\"> <para> <literal>property-ref</literal>: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class !
is used. </para> </callout> </calloutlist> </programlistingco>"
+msgstr ""
+
+#: index.docbook:480
+msgid "Some examples, first, a set of strings:"
+msgstr ""
+
+#: index.docbook:484
+msgid ""
+ "<![CDATA[<set name=\"names\" table=\"person_names\">\n"
+ " <key column=\"person_id\"/>\n"
+ " <element column=\"person_name\" type=\"string\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:486
+msgid "A bag containing integers (with an iteration order determined by the <literal>order-by</literal> attribute):"
+msgstr ""
+
+#: index.docbook:491
+msgid ""
+ "<![CDATA[<bag name=\"sizes\" \n"
+ " table=\"item_sizes\" \n"
+ " order-by=\"size asc\">\n"
+ " <key column=\"item_id\"/>\n"
+ " <element column=\"size\" type=\"integer\"/>\n"
+ "</bag>]]>"
+msgstr ""
+
+#: index.docbook:493
+msgid "An array of entities - in this case, a many to many association:"
+msgstr ""
+
+#: index.docbook:497
+msgid ""
+ "<![CDATA[<array name=\"addresses\" \n"
+ " table=\"PersonAddress\" \n"
+ " cascade=\"persist\">\n"
+ " <key column=\"personId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <many-to-many column=\"addressId\" class=\"Address\"/>\n"
+ "</array>]]>"
+msgstr ""
+
+#: index.docbook:499
+msgid "A map from string indices to dates:"
+msgstr ""
+
+#: index.docbook:503
+msgid ""
+ "<![CDATA[<map name=\"holidays\" \n"
+ " table=\"holidays\" \n"
+ " schema=\"dbo\" \n"
+ " order-by=\"hol_name asc\">\n"
+ " <key column=\"id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:505
+msgid "A list of components (discussed in the next chapter):"
+msgstr ""
+
+#: index.docbook:509
+msgid ""
+ "<![CDATA[<list name=\"carComponents\" \n"
+ " table=\"CarComponents\">\n"
+ " <key column=\"carId\"/>\n"
+ " <list-index column=\"sortOrder\"/>\n"
+ " <composite-element class=\"CarComponent\">\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"type\"/>\n"
+ " <property name=\"serialNumber\" column=\"serialNum\"/>\n"
+ " </composite-element>\n"
+ "</list>]]>"
+msgstr ""
+
+#: index.docbook:514
+msgid "One-to-many associations"
+msgstr ""
+
+#: index.docbook:516
+msgid "A <emphasis>one to many association</emphasis> links the tables of two classes via a foreign key, with no intervening collection table. This mapping loses certain semantics of normal Java collections:"
+msgstr ""
+
+#: index.docbook:524
+msgid "An instance of the contained entity class may not belong to more than one instance of the collection"
+msgstr ""
+
+#: index.docbook:530
+msgid "An instance of the contained entity class may not appear at more than one value of the collection index"
+msgstr ""
+
+#: index.docbook:537
+msgid "An association from <literal>Product</literal> to <literal>Part</literal> requires existence of a foreign key column and possibly an index column to the <literal>Part</literal> table. A <literal><one-to-many></literal> tag indicates that this is a one to many association."
+msgstr ""
+
+#: index.docbook:550
+msgid ""
+ "<![CDATA[<one-to-many \n"
+ " class=\"ClassName\"\n"
+ " not-found=\"ignore|exception\"\n"
+ " entity-name=\"EntityName\"\n"
+ " node=\"element-name\"\n"
+ " embed-xml=\"true|false\"\n"
+ " />]]>"
+msgstr ""
+
+#: index.docbook:553
+msgid "<literal>class</literal> (required): The name of the associated class."
+msgstr ""
+
+#: index.docbook:558
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): Specifies how cached identifiers that reference missing rows will be handled: <literal>ignore</literal> will treat a missing row as a null association."
+msgstr ""
+
+#: index.docbook:565
+msgid "<literal>entity-name</literal> (optional): The entity name of the associated class, as an alternative to <literal>class</literal>."
+msgstr ""
+
+#: index.docbook:573
+msgid "Notice that the <literal><one-to-many></literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere."
+msgstr ""
+
+#: index.docbook:579
+msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal><one-to-many></literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal><key></literal> mapping <literal>not-null=\"true\"</literal> or <emphasis>use a bidirectional association</emphasis> with the collection mapping marked <literal>inverse=\"true\"</literal>. See the discussion of bidirectional associations later in this chapter."
+msgstr ""
+
+#: index.docbook:588
+msgid "This example shows a map of <literal>Part</literal> entities by name (where <literal>partName</literal> is a persistent property of <literal>Part</literal>). Notice the use of a formula-based index."
+msgstr ""
+
+#: index.docbook:594
+msgid ""
+ "<![CDATA[<map name=\"parts\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"productId\" not-null=\"true\"/>\n"
+ " <map-key formula=\"partName\"/>\n"
+ " <one-to-many class=\"Part\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:600
+msgid "Advanced collection mappings"
+msgstr ""
+
+#: index.docbook:603
+msgid "Sorted collections"
+msgstr ""
+
+#: index.docbook:605
+msgid "Hibernate supports collections implementing <literal>java.util.SortedMap</literal> and <literal>java.util.SortedSet</literal>. You must specify a comparator in the mapping file:"
+msgstr ""
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<set name=\"aliases\" \n"
+ " table=\"person_aliases\" \n"
+ " sort=\"natural\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date\" type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:612
+msgid "Allowed values of the <literal>sort</literal> attribute are <literal>unsorted</literal>, <literal>natural</literal> and the name of a class implementing <literal>java.util.Comparator</literal>."
+msgstr ""
+
+#: index.docbook:618
+msgid "Sorted collections actually behave like <literal>java.util.TreeSet</literal> or <literal>java.util.TreeMap</literal>."
+msgstr ""
+
+#: index.docbook:623
+msgid "If you want the database itself to order the collection elements use the <literal>order-by</literal> attribute of <literal>set</literal>, <literal>bag</literal> or <literal>map</literal> mappings. This solution is only available under JDK 1.4 or higher (it is implemented using <literal>LinkedHashSet</literal> or <literal>LinkedHashMap</literal>). This performs the ordering in the SQL query, not in memory."
+msgstr ""
+
+#: index.docbook:632
+msgid ""
+ "<![CDATA[<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc\">\n"
+ " <key column=\"person\"/>\n"
+ " <element column=\"name\" type=\"string\"/>\n"
+ "</set>\n"
+ "\n"
+ "<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
+ " <key column=\"year_id\"/>\n"
+ " <map-key column=\"hol_name\" type=\"string\"/>\n"
+ " <element column=\"hol_date type=\"date\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:634
+msgid "Note that the value of the <literal>order-by</literal> attribute is an SQL ordering, not a HQL ordering!"
+msgstr ""
+
+#: index.docbook:639
+msgid "Associations may even be sorted by some arbitrary criteria at runtime using a collection <literal>filter()</literal>."
+msgstr ""
+
+#: index.docbook:644
+msgid "<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list();]]>"
+msgstr ""
+
+#: index.docbook:649
+msgid "Bidirectional associations"
+msgstr ""
+
+#: index.docbook:651
+msgid "A <emphasis>bidirectional association</emphasis> allows navigation from both \"ends\" of the association. Two kinds of bidirectional association are supported:"
+msgstr ""
+
+#: index.docbook:658
+msgid "one-to-many"
+msgstr ""
+
+#: index.docbook:660
+msgid "set or bag valued at one end, single-valued at the other"
+msgstr ""
+
+#: index.docbook:666
+msgid "many-to-many"
+msgstr ""
+
+#: index.docbook:668
+msgid "set or bag valued at both ends"
+msgstr ""
+
+#: index.docbook:677
+msgid "You may specify a bidirectional many-to-many association simply by mapping two many-to-many associations to the same database table and declaring one end as <emphasis>inverse</emphasis> (which one is your choice, but it can not be an indexed collection)."
+msgstr ""
+
+#: index.docbook:684
+msgid "Here's an example of a bidirectional many-to-many association; each category can have many items and each item can be in many categories:"
+msgstr ""
+
+#: index.docbook:689
+msgid ""
+ "<![CDATA[<class name=\"Category\">\n"
+ " <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
+ " ...\n"
+ " <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
+ " <key column=\"CATEGORY_ID\"/>\n"
+ " <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
+ " </bag>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Item\">\n"
+ " <id name=\"id\" column=\"ITEM_ID\"/>\n"
+ " ...\n"
+ "\n"
+ " <!-- inverse end -->\n"
+ " <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true\">\n"
+ " <key column=\"ITEM_ID\"/>\n"
+ " <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
+ " </bag>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:691
+msgid "Changes made only to the inverse end of the association are <emphasis>not</emphasis> persisted. This means that Hibernate has two representations in memory for every bidirectional association, one link from A to B and another link from B to A. This is easier to understand if you think about the Java object model and how we create a many-to-many relationship in Java:"
+msgstr ""
+
+#: index.docbook:699
+msgid ""
+ "<![CDATA[\n"
+ "category.getItems().add(item); // The category now \"knows\" about the relationship\n"
+ "item.getCategories().add(category); // The item now \"knows\" about the relationship\n"
+ "\n"
+ "session.persist(item); // The relationship won't be saved!\n"
+ "session.persist(category); // The relationship will be saved]]>"
+msgstr ""
+
+#: index.docbook:701
+msgid "The non-inverse side is used to save the in-memory representation to the database."
+msgstr ""
+
+#: index.docbook:705
+msgid "You may define a bidirectional one-to-many association by mapping a one-to-many association to the same table column(s) as a many-to-one association and declaring the many-valued end <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:713
+msgid "Mapping one end of an association with <literal>inverse=\"true\"</literal> doesn't affect the operation of cascades, these are orthogonal concepts!"
+msgstr ""
+
+#: index.docbook:721
+msgid "Bidirectional associations with indexed collections"
+msgstr ""
+
+#: index.docbook:722
+msgid "A bidirectional association where one end is represented as a <literal><list></literal> or <literal><map></literal> requires special consideration. If there is a property of the child class which maps to the index column, no problem, we can continue using <literal>inverse=\"true\"</literal> on the collection mapping:"
+msgstr ""
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"/>\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:731
+msgid "But, if there is no such property on the child class, we can't think of the association as truly bidirectional (there is information available at one end of the association that is not available at the other end). In this case, we can't map the collection <literal>inverse=\"true\"</literal>. Instead, we could use the following mapping:"
+msgstr ""
+
+#: index.docbook:738
+msgid ""
+ "<![CDATA[<class name=\"Parent\">\n"
+ " <id name=\"id\" column=\"parent_id\"/>\n"
+ " ....\n"
+ " <map name=\"children\">\n"
+ " <key column=\"parent_id\"\n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"name\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </map>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Child\">\n"
+ " <id name=\"id\" column=\"child_id\"/>\n"
+ " ....\n"
+ " <many-to-one name=\"parent\" \n"
+ " class=\"Parent\" \n"
+ " column=\"parent_id\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\"\n"
+ " not-null=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:740
+msgid "Note that in this mapping, the collection-valued end of the association is responsible for updates to the foreign key. TODO: Does this really result in some unnecessary update statements?"
+msgstr ""
+
+#: index.docbook:748
+msgid "Ternary associations"
+msgstr ""
+
+#: index.docbook:750
+msgid "There are three possible approaches to mapping a ternary association. One is to use a <literal>Map</literal> with an association as its index:"
+msgstr ""
+
+#: index.docbook:755
+msgid ""
+ "<![CDATA[<map name=\"contracts\">\n"
+ " <key column=\"employer_id\" not-null=\"true\"/>\n"
+ " <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
+ " <one-to-many class=\"Contract\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[<map name=\"connections\">\n"
+ " <key column=\"incoming_node_id\"/>\n"
+ " <map-key-many-to-many column=\"outgoing_node_id\" class=\"Node\"/>\n"
+ " <many-to-many column=\"connection_id\" class=\"Connection\"/>\n"
+ "</map>]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "A second approach is to simply remodel the association as an entity class. This is the approach we use most commonly."
+msgstr ""
+
+#: index.docbook:764
+msgid "A final alternative is to use composite elements, which we will discuss later."
+msgstr ""
+
+#: index.docbook:771
+msgid "Using an <idbag>"
+msgstr ""
+
+#: index.docbook:773
+msgid "If you've fully embraced our view that composite keys are a bad thing and that entities should have synthetic identifiers (surrogate keys), then you might find it a bit odd that the many to many associations and collections of values that we've shown so far all map to tables with composite keys! Now, this point is quite arguable; a pure association table doesn't seem to benefit much from a surrogate key (though a collection of composite values <emphasis>might</emphasis>). Nevertheless, Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key."
+msgstr ""
+
+#: index.docbook:784
+msgid "The <literal><idbag></literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics."
+msgstr ""
+
+#: index.docbook:789
+msgid ""
+ "<![CDATA[<idbag name=\"lovers\" table=\"LOVERS\">\n"
+ " <collection-id column=\"ID\" type=\"long\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </collection-id>\n"
+ " <key column=\"PERSON1\"/>\n"
+ " <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/>\n"
+ "</idbag>]]>"
+msgstr ""
+
+#: index.docbook:791
+msgid "As you can see, an <literal><idbag></literal> has a synthetic id generator, just like an entity class! A different surrogate key is assigned to each collection row. Hibernate does not provide any mechanism to discover the surrogate key value of a particular row, however."
+msgstr ""
+
+#: index.docbook:798
+msgid "Note that the update performance of an <literal><idbag></literal> is <emphasis>much</emphasis> better than a regular <literal><bag></literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set."
+msgstr ""
+
+#: index.docbook:805
+msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal><idbag></literal> collection identifiers."
+msgstr ""
+
+#: index.docbook:829
+msgid "Collection examples"
+msgstr ""
+
+#: index.docbook:831
+msgid "The previous sections are pretty confusing. So lets look at an example. This class:"
+msgstr ""
+
+#: index.docbook:836
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "\n"
+ "public class Parent {\n"
+ " private long id;\n"
+ " private Set children;\n"
+ "\n"
+ " public long getId() { return id; }\n"
+ " private void setId(long id) { this.id=id; }\n"
+ "\n"
+ " private Set getChildren() { return children; }\n"
+ " private void setChildren(Set children) { this.children=children; }\n"
+ "\n"
+ " ....\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:838
+msgid "has a collection of <literal>Child</literal> instances. If each child has at most one parent, the most natural mapping is a one-to-many association:"
+msgstr ""
+
+#: index.docbook:844
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:846
+msgid "This maps to the following table definitions:"
+msgstr ""
+
+#: index.docbook:850
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+
+#: index.docbook:852
+msgid "If the parent is <emphasis>required</emphasis>, use a bidirectional one-to-many association:"
+msgstr ""
+
+#: index.docbook:857
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id\" not-null=\"true\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:859
+msgid "Notice the <literal>NOT NULL</literal> constraint:"
+msgstr ""
+
+#: index.docbook:863
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null\n"
+ " primary key,\n"
+ " name varchar(255),\n"
+ " parent_id bigint not null )\n"
+ "alter table child add constraint childfk0 (parent_id) references parent]]>"
+msgstr ""
+
+#: index.docbook:865
+msgid "Alternatively, if you absolutely insist that this association should be unidirectional, you can declare the <literal>NOT NULL</literal> constraint on the <literal><key></literal> mapping:"
+msgstr ""
+
+#: index.docbook:871
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:873
+msgid "On the other hand, if a child might have multiple parents, a many-to-many association is appropriate:"
+msgstr ""
+
+#: index.docbook:878
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Parent\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <set name=\"children\" table=\"childset\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <many-to-many class=\"Child\" column=\"child_id\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Child\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:880
+msgid "Table definitions:"
+msgstr ""
+
+#: index.docbook:884
+msgid ""
+ "<![CDATA[create table parent ( id bigint not null primary key )\n"
+ "create table child ( id bigint not null primary key, name varchar(255) )\n"
+ "create table childset ( parent_id bigint not null,\n"
+ " child_id bigint not null,\n"
+ " primary key ( parent_id, child_id ) )\n"
+ "alter table childset add constraint childsetfk0 (parent_id) references parent\n"
+ "alter table childset add constraint childsetfk1 (child_id) references child]]>"
+msgstr ""
+
+#: index.docbook:886
+msgid "For more examples and a complete walk-through a parent/child relationship mapping, see <xref linkend=\"example-parentchild\"/>."
+msgstr ""
+
+#: index.docbook:891
+msgid "Even more exotic association mappings are possible, we will catalog all possibilities in the next chapter."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/component_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/component_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/component_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,372 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Component Mapping"
+msgstr ""
+
+#: index.docbook:7
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts, for different purposes, throughout Hibernate."
+msgstr ""
+
+#: index.docbook:13
+msgid "Dependent objects"
+msgstr ""
+
+#: index.docbook:15
+msgid "A component is a contained object that is persisted as a value type, not an entity reference. The term \"component\" refers to the object-oriented notion of composition (not to architecture-level components). For example, you might model a person like this:"
+msgstr ""
+
+#: index.docbook:21
+msgid ""
+ "<![CDATA[public class Person {\n"
+ " private java.util.Date birthday;\n"
+ " private Name name;\n"
+ " private String key;\n"
+ " public String getKey() {\n"
+ " return key;\n"
+ " }\n"
+ " private void setKey(String key) {\n"
+ " this.key=key;\n"
+ " }\n"
+ " public java.util.Date getBirthday() {\n"
+ " return birthday;\n"
+ " }\n"
+ " public void setBirthday(java.util.Date birthday) {\n"
+ " this.birthday = birthday;\n"
+ " }\n"
+ " public Name getName() {\n"
+ " return name;\n"
+ " }\n"
+ " public void setName(Name name) {\n"
+ " this.name = name;\n"
+ " }\n"
+ " ......\n"
+ " ......\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:23
+msgid ""
+ "<![CDATA[public class Name {\n"
+ " char initial;\n"
+ " String first;\n"
+ " String last;\n"
+ " public String getFirst() {\n"
+ " return first;\n"
+ " }\n"
+ " void setFirst(String first) {\n"
+ " this.first = first;\n"
+ " }\n"
+ " public String getLast() {\n"
+ " return last;\n"
+ " }\n"
+ " void setLast(String last) {\n"
+ " this.last = last;\n"
+ " }\n"
+ " public char getInitial() {\n"
+ " return initial;\n"
+ " }\n"
+ " void setInitial(char initial) {\n"
+ " this.initial = initial;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:25
+msgid "Now <literal>Name</literal> may be persisted as a component of <literal>Person</literal>. Notice that <literal>Name</literal> defines getter and setter methods for its persistent properties, but doesn't need to declare any interfaces or identifier properties."
+msgstr ""
+
+#: index.docbook:32
+msgid "Our Hibernate mapping would look like:"
+msgstr ""
+
+#: index.docbook:36
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\"> <!-- class attribute optional -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:38
+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 ""
+
+#: index.docbook:46
+msgid "Like all 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 ojects, 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 should be okay for most purposes."
+msgstr ""
+
+#: index.docbook:55
+msgid "The properties of a component may 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 very fine-grained object model."
+msgstr ""
+
+#: index.docbook:62
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr ""
+
+#: index.docbook:68
+msgid ""
+ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
+ " <id name=\"Key\" column=\"pid\" type=\"string\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " <property name=\"birthday\" type=\"date\"/>\n"
+ " <component name=\"Name\" class=\"eg.Name\" unique=\"true\">\n"
+ " <parent name=\"namedPerson\"/> <!-- reference back to the Person -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </component>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "Collections of dependent objects"
+msgstr ""
+
+#: index.docbook:75
+msgid "Collections of components are supported (eg. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal><element></literal> tag with a <literal><composite-element></literal> tag."
+msgstr ""
+
+#: index.docbook:82
+msgid ""
+ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
+ " <key column=\"id\"/>\n"
+ " <composite-element class=\"eg.Name\"> <!-- class attribute required -->\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"first\"/>\n"
+ " <property name=\"last\"/>\n"
+ " </composite-element>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:84
+msgid "Note: if you define a <literal>Set</literal> of composite elements, it is very important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr ""
+
+#: index.docbook:90
+msgid "Composite elements may contain components but not collections. If your composite element itself contains components, use the <literal><nested-composite-element></literal> tag. This is a pretty exotic case - a collection of components which themselves have components. By this stage you should be asking yourself if a one-to-many association is more appropriate. Try remodelling the composite element as an entity - but note that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr ""
+
+#: index.docbook:102
+msgid "Please note that a composite element mapping doesn't support null-able properties if you're using a <literal><set></literal>. Hibernate has to use each columns value to identify a record when deleting objects (there is no separate primary key column in the composite element table), which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal><list></literal>, <literal><map></literal>, <literal><bag></literal> or <literal><idbag></literal>."
+msgstr ""
+
+#: index.docbook:113
+msgid "A special case of a composite element is a composite element with a nested <literal><many-to-one></literal> element. A mapping like this 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 ""
+
+#: index.docbook:123
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.Purchase\">\n"
+ " <property name=\"purchaseDate\"/>\n"
+ " <property name=\"price\"/>\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/> <!-- class attribute is optional -->\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:125
+msgid "Of course, there can't be a reference to the purchae on the other side, for bidirectional association navigation. Remember that components are value types and don't allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it can't be referenced by the <literal>Item</literal> at the same time."
+msgstr ""
+
+#: index.docbook:133
+msgid "Even ternary (or quaternary, etc) associations are possible:"
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<class name=\"eg.Order\" .... >\n"
+ " ....\n"
+ " <set name=\"purchasedItems\" table=\"purchase_items\" lazy=\"true\">\n"
+ " <key column=\"order_id\">\n"
+ " <composite-element class=\"eg.OrderLine\">\n"
+ " <many-to-one name=\"purchaseDetails class=\"eg.Purchase\"/>\n"
+ " <many-to-one name=\"item\" class=\"eg.Item\"/>\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:137
+msgid "Composite elements may appear in queries using the same syntax as associations to other entities."
+msgstr ""
+
+#: index.docbook:145
+msgid "Components as Map indices"
+msgstr ""
+
+#: index.docbook:147
+msgid "The <literal><composite-map-key></literal> element lets you map a component class as the key of a <literal>Map</literal>. Make sure you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr ""
+
+#: index.docbook:156
+msgid "Components as composite identifiers"
+msgstr ""
+
+#: index.docbook:158
+msgid "You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr ""
+
+#: index.docbook:165
+msgid "It must implement <literal>java.io.Serializable</literal>."
+msgstr ""
+
+#: index.docbook:170
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal>, consistently with the database's notion of composite key equality."
+msgstr ""
+
+#: index.docbook:179
+msgid "Note: in Hibernate3, the second requirement is not an absolutely hard requirement of Hibernate. But do it anyway."
+msgstr ""
+
+#: index.docbook:183
+msgid "You can't use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr ""
+
+#: index.docbook:188
+msgid "Use the <literal><composite-id></literal> tag (with nested <literal><key-property></literal> elements) in place of the usual <literal><id></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 ""
+
+#: index.docbook:196
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " \n"
+ " <composite-id name=\"id\" class=\"OrderLineId\">\n"
+ " <key-property name=\"lineId\"/>\n"
+ " <key-property name=\"orderId\"/>\n"
+ " <key-property name=\"customerId\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"name\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\" class=\"Order\"\n"
+ " insert=\"false\" update=\"false\">\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-one>\n"
+ " ....\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:198
+msgid "Now, any foreign keys referencing the <literal>OrderLine</literal> table are also composite. You must declare this in your mappings for other classes. An association to <literal>OrderLine</literal> would be mapped like this:"
+msgstr ""
+
+#: index.docbook:204
+msgid ""
+ "<![CDATA[<many-to-one name=\"orderLine\" class=\"OrderLine\">\n"
+ "<!-- the \"class\" attribute is optional, as usual -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ "</many-to-one>]]>"
+msgstr ""
+
+#: index.docbook:206
+msgid "(Note that the <literal><column></literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)"
+msgstr ""
+
+#: index.docbook:211
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr ""
+
+#: index.docbook:216
+msgid ""
+ "<![CDATA[<set name=\"undeliveredOrderLines\">\n"
+ " <key column name=\"warehouseId\"/>\n"
+ " <many-to-many class=\"OrderLine\">\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </many-to-many>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:218
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr ""
+
+#: index.docbook:223
+msgid ""
+ "<![CDATA[<set name=\"orderLines\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"OrderLine\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:225
+msgid "(The <literal><one-to-many></literal> element, as usual, declares no columns.)"
+msgstr ""
+
+#: index.docbook:229
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
+msgstr ""
+
+#: index.docbook:234
+msgid ""
+ "<![CDATA[<class name=\"OrderLine\">\n"
+ " ....\n"
+ " ....\n"
+ " <list name=\"deliveryAttempts\">\n"
+ " <key> <!-- a collection inherits the composite key type -->\n"
+ " <column name=\"lineId\"/>\n"
+ " <column name=\"orderId\"/>\n"
+ " <column name=\"customerId\"/>\n"
+ " </key>\n"
+ " <list-index column=\"attemptId\" base=\"1\"/>\n"
+ " <composite-element class=\"DeliveryAttempt\">\n"
+ " ...\n"
+ " </composite-element>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:239
+msgid "Dynamic components"
+msgstr ""
+
+#: index.docbook:241
+msgid "You may even map a property of type <literal>Map</literal>:"
+msgstr ""
+
+#: index.docbook:245
+msgid ""
+ "<![CDATA[<dynamic-component name=\"userAttributes\">\n"
+ " <property name=\"foo\" column=\"FOO\" type=\"string\"/>\n"
+ " <property name=\"bar\" column=\"BAR\" type=\"integer\"/>\n"
+ " <many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/>\n"
+ "</dynamic-component>]]>"
+msgstr ""
+
+#: index.docbook:247
+msgid "The semantics of a <literal><dynamic-component></literal> mapping are identical to <literal><component></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. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/configuration.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/configuration.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/configuration.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1489 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Configuration"
+msgstr ""
+
+#: index.docbook:7
+msgid "Because Hibernate is designed to operate in many different environments, there are a large number of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that shows the various options. Just put the example file in your classpath and customize it."
+msgstr ""
+
+#: index.docbook:16
+msgid "Programmatic configuration"
+msgstr ""
+
+#: index.docbook:18
+msgid "An instance of <literal>org.hibernate.cfg.Configuration</literal> represents an entire set of mappings of an application's Java types to an SQL database. The <literal>Configuration</literal> is used to build an (immutable) <literal>SessionFactory</literal>. The mappings are compiled from various XML mapping files."
+msgstr ""
+
+#: index.docbook:26
+msgid "You may obtain a <literal>Configuration</literal> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>:"
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addResource(\"Item.hbm.xml\")\n"
+ " .addResource(\"Bid.hbm.xml\");]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "An alternative (sometimes better) way is to specify the mapped class, and let Hibernate find the mapping document for you:"
+msgstr ""
+
+#: index.docbook:39
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class);]]>"
+msgstr ""
+
+#: index.docbook:41
+msgid "Then Hibernate will look for mapping files named <literal>/org/hibernate/auction/Item.hbm.xml</literal> and <literal>/org/hibernate/auction/Bid.hbm.xml</literal> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr ""
+
+#: index.docbook:48
+msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:"
+msgstr ""
+
+#: index.docbook:53
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration()\n"
+ " .addClass(org.hibernate.auction.Item.class)\n"
+ " .addClass(org.hibernate.auction.Bid.class)\n"
+ " .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
+ " .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
+ " .setProperty(\"hibernate.order_updates\", \"true\");]]>"
+msgstr ""
+
+#: index.docbook:55
+msgid "This is not the only way to pass configuration properties to Hibernate. The various options include:"
+msgstr ""
+
+#: index.docbook:62
+msgid "Pass an instance of <literal>java.util.Properties</literal> to <literal>Configuration.setProperties()</literal>."
+msgstr ""
+
+#: index.docbook:68
+msgid "Place <literal>hibernate.properties</literal> in a root directory of the classpath."
+msgstr ""
+
+#: index.docbook:74
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr ""
+
+#: index.docbook:80
+msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)."
+msgstr ""
+
+#: index.docbook:87
+msgid "<literal>hibernate.properties</literal> is the easiest approach if you want to get started quickly."
+msgstr ""
+
+#: index.docbook:92
+msgid "The <literal>Configuration</literal> is intended as a startup-time object, to be discarded once a <literal>SessionFactory</literal> is created."
+msgstr ""
+
+#: index.docbook:100
+msgid "Obtaining a SessionFactory"
+msgstr ""
+
+#: index.docbook:102
+msgid "When all mappings have been parsed by the <literal>Configuration</literal>, the application must obtain a factory for <literal>Session</literal> instances. This factory is intended to be shared by all application threads:"
+msgstr ""
+
+#: index.docbook:108
+msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "Hibernate does allow your application to instantiate more than one <literal>SessionFactory</literal>. This is useful if you are using more than one database."
+msgstr ""
+
+#: index.docbook:119
+msgid "JDBC connections"
+msgstr ""
+
+#: index.docbook:121
+msgid "Usually, you want to have the <literal>SessionFactory</literal> create and pool JDBC connections for you. If you take this approach, opening a <literal>Session</literal> is as simple as:"
+msgstr ""
+
+#: index.docbook:127
+msgid "<![CDATA[Session session = sessions.openSession(); // open a new Session]]>"
+msgstr ""
+
+#: index.docbook:129
+msgid "As soon as you do something that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr ""
+
+#: index.docbook:134
+msgid "For this to work, we need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <literal>org.hibernate.cfg.Environment</literal>. We will now describe the most important settings for JDBC connection configuration."
+msgstr ""
+
+#: index.docbook:141
+msgid "Hibernate will obtain (and pool) connections using <literal>java.sql.DriverManager</literal> if you set the following properties:"
+msgstr ""
+
+#: index.docbook:147
+msgid "Hibernate JDBC Properties"
+msgstr ""
+
+#: index.docbook:153, index.docbook:241, index.docbook:338, index.docbook:529, index.docbook:725, index.docbook:832, index.docbook:920
+msgid "Property name"
+msgstr ""
+
+#: index.docbook:154, index.docbook:242, index.docbook:339, index.docbook:530, index.docbook:726, index.docbook:833, index.docbook:921
+msgid "Purpose"
+msgstr ""
+
+#: index.docbook:160
+msgid "hibernate.connection.driver_class"
+msgstr ""
+
+#: index.docbook:163
+msgid "JDBC driver class"
+msgstr ""
+
+#: index.docbook:168
+msgid "hibernate.connection.url"
+msgstr ""
+
+#: index.docbook:171
+msgid "JDBC URL"
+msgstr ""
+
+#: index.docbook:176, index.docbook:272
+msgid "hibernate.connection.username"
+msgstr ""
+
+#: index.docbook:179
+msgid "database user"
+msgstr ""
+
+#: index.docbook:184, index.docbook:280
+msgid "hibernate.connection.password"
+msgstr ""
+
+#: index.docbook:187
+msgid "database user password"
+msgstr ""
+
+#: index.docbook:192
+msgid "hibernate.connection.pool_size"
+msgstr ""
+
+#: index.docbook:195
+msgid "maximum number of pooled connections"
+msgstr ""
+
+#: index.docbook:202
+msgid "Hibernate's own connection pooling algorithm is however quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis> or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <literal>hibernate.connection.pool_size</literal> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use C3P0."
+msgstr ""
+
+#: index.docbook:212
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <literal>lib</literal> directory. Hibernate will use its <literal>C3P0ConnectionProvider</literal> for connection pooling if you set <literal>hibernate.c3p0.*</literal> properties. If you'd like to use Proxool refer to the packaged <literal>hibernate.properties</literal> and the Hibernate web site for more information."
+msgstr ""
+
+#: index.docbook:221
+msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:"
+msgstr ""
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
+ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
+ "hibernate.connection.username = myuser\n"
+ "hibernate.connection.password = secret\n"
+ "hibernate.c3p0.min_size=5\n"
+ "hibernate.c3p0.max_size=20\n"
+ "hibernate.c3p0.timeout=1800\n"
+ "hibernate.c3p0.max_statements=50\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <literal>Datasource</literal> registered in JNDI. You'll need to set at least one of the following properties:"
+msgstr ""
+
+#: index.docbook:235
+msgid "Hibernate Datasource Properties"
+msgstr ""
+
+#: index.docbook:248
+msgid "hibernate.connection.datasource"
+msgstr ""
+
+#: index.docbook:251
+msgid "datasource JNDI name"
+msgstr ""
+
+#: index.docbook:256
+msgid "hibernate.jndi.url"
+msgstr ""
+
+#: index.docbook:258
+msgid "<emphasis>URL of the JNDI provider</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:264
+msgid "hibernate.jndi.class"
+msgstr ""
+
+#: index.docbook:266
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:274
+msgid "<emphasis>database user</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:282
+msgid "<emphasis>database user password</emphasis> (optional)"
+msgstr ""
+
+#: index.docbook:290
+msgid "Here's an example <literal>hibernate.properties</literal> file for an application server provided JNDI datasource:"
+msgstr ""
+
+#: index.docbook:295
+msgid ""
+ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
+ "hibernate.transaction.factory_class = \\\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ "hibernate.transaction.manager_lookup_class = \\\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup\n"
+ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
+msgstr ""
+
+#: index.docbook:297
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr ""
+
+#: index.docbook:302
+msgid "Arbitrary connection properties may be given by prepending \"<literal>hibernate.connection</literal>\" to the property name. For example, you may specify a <literal>charSet</literal> using <literal>hibernate.connection.charSet</literal>."
+msgstr ""
+
+#: index.docbook:308
+msgid "You may define your own plugin strategy for obtaining JDBC connections by implementing the interface <literal>org.hibernate.connection.ConnectionProvider</literal>. You may select a custom implementation by setting <literal>hibernate.connection.provider_class</literal>."
+msgstr ""
+
+#: index.docbook:317
+msgid "Optional configuration properties"
+msgstr ""
+
+#: index.docbook:319
+msgid "There are a number of other properties that control the behaviour of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr ""
+
+#: index.docbook:324
+msgid "<emphasis>Warning: some of these properties are \"system-level\" only.</emphasis> System-level properties can be set only via <literal>java -Dproperty=value</literal> or <literal>hibernate.properties</literal>. They may <emphasis>not</emphasis> be set by the other techniques described above."
+msgstr ""
+
+#: index.docbook:332
+msgid "Hibernate Configuration Properties"
+msgstr ""
+
+#: index.docbook:345
+msgid "hibernate.dialect"
+msgstr ""
+
+#: index.docbook:347
+msgid "The classname of a Hibernate <literal>Dialect</literal> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr ""
+
+#: index.docbook:351
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr ""
+
+#: index.docbook:359
+msgid "hibernate.show_sql"
+msgstr ""
+
+#: index.docbook:361
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr ""
+
+#: index.docbook:365, index.docbook:377, index.docbook:471, index.docbook:484, index.docbook:497, index.docbook:510, index.docbook:564, index.docbook:591, index.docbook:605, index.docbook:660, index.docbook:888, index.docbook:903, index.docbook:993
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr ""
+
+#: index.docbook:373
+msgid "hibernate.format_sql"
+msgstr ""
+
+#: index.docbook:375
+msgid "Pretty print the SQL in the log and console."
+msgstr ""
+
+#: index.docbook:385
+msgid "hibernate.default_schema"
+msgstr ""
+
+#: index.docbook:387
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr ""
+
+#: index.docbook:390
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr ""
+
+#: index.docbook:398
+msgid "hibernate.default_catalog"
+msgstr ""
+
+#: index.docbook:400
+msgid "Qualify unqualified table names with the given catalog in generated SQL."
+msgstr ""
+
+#: index.docbook:403
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr ""
+
+#: index.docbook:411
+msgid "hibernate.session_factory_name"
+msgstr ""
+
+#: index.docbook:413
+msgid "The <literal>SessionFactory</literal> will be automatically bound to this name in JNDI after it has been created."
+msgstr ""
+
+#: index.docbook:416, index.docbook:859
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr ""
+
+#: index.docbook:424
+msgid "hibernate.max_fetch_depth"
+msgstr ""
+
+#: index.docbook:426
+msgid "Set a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr ""
+
+#: index.docbook:430
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr ""
+
+#: index.docbook:439
+msgid "hibernate.default_batch_fetch_size"
+msgstr ""
+
+#: index.docbook:441
+msgid "Set a default size for Hibernate batch fetching of associations."
+msgstr ""
+
+#: index.docbook:443
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr ""
+
+#: index.docbook:452
+msgid "hibernate.default_entity_mode"
+msgstr ""
+
+#: index.docbook:454
+msgid "Set a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:457
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr ""
+
+#: index.docbook:465
+msgid "hibernate.order_updates"
+msgstr ""
+
+#: index.docbook:467
+msgid "Force Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr ""
+
+#: index.docbook:479
+msgid "hibernate.generate_statistics"
+msgstr ""
+
+#: index.docbook:481
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
+msgstr ""
+
+#: index.docbook:492
+msgid "hibernate.use_identifier_rollback"
+msgstr ""
+
+#: index.docbook:494
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
+msgstr ""
+
+#: index.docbook:505
+msgid "hibernate.use_sql_comments"
+msgstr ""
+
+#: index.docbook:507
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr ""
+
+#: index.docbook:521
+msgid "Hibernate JDBC and Connection Properties"
+msgstr ""
+
+#: index.docbook:536
+msgid "hibernate.jdbc.fetch_size"
+msgstr ""
+
+#: index.docbook:538
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr ""
+
+#: index.docbook:545
+msgid "hibernate.jdbc.batch_size"
+msgstr ""
+
+#: index.docbook:547
+msgid "A non-zero value enables use of JDBC2 batch updates by Hibernate."
+msgstr ""
+
+#: index.docbook:549
+msgid "<emphasis role=\"strong\">eg.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr ""
+
+#: index.docbook:557
+msgid "hibernate.jdbc.batch_versioned_data"
+msgstr ""
+
+#: index.docbook:559
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal> (it is usually safe to turn this option on). Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr ""
+
+#: index.docbook:572
+msgid "hibernate.jdbc.factory_class"
+msgstr ""
+
+#: index.docbook:574
+msgid "Select a custom <literal>Batcher</literal>. Most applications will not need this configuration property."
+msgstr ""
+
+#: index.docbook:577
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr ""
+
+#: index.docbook:585
+msgid "hibernate.jdbc.use_scrollable_resultset"
+msgstr ""
+
+#: index.docbook:587
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user supplied JDBC connections, Hibernate uses connection metadata otherwise."
+msgstr ""
+
+#: index.docbook:599
+msgid "hibernate.jdbc.use_streams_for_binary"
+msgstr ""
+
+#: index.docbook:601
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC (system-level property)."
+msgstr ""
+
+#: index.docbook:613
+msgid "hibernate.jdbc.use_get_generated_keys"
+msgstr ""
+
+#: index.docbook:615
+msgid "Enable use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, tries to determine the driver capabilities using connection metadata."
+msgstr ""
+
+#: index.docbook:621, index.docbook:751, index.docbook:763, index.docbook:777, index.docbook:815
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>true|false</literal>"
+msgstr ""
+
+#: index.docbook:629
+msgid "hibernate.connection.provider_class"
+msgstr ""
+
+#: index.docbook:631
+msgid "The classname of a custom <literal>ConnectionProvider</literal> which provides JDBC connections to Hibernate."
+msgstr ""
+
+#: index.docbook:634
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr ""
+
+#: index.docbook:642
+msgid "hibernate.connection.isolation"
+msgstr ""
+
+#: index.docbook:644
+msgid "Set the JDBC transaction isolation level. Check <literal>java.sql.Connection</literal> for meaningful values but note that most databases do not support all isolation levels."
+msgstr ""
+
+#: index.docbook:648
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>1, 2, 4, 8</literal>"
+msgstr ""
+
+#: index.docbook:656
+msgid "hibernate.connection.autocommit"
+msgstr ""
+
+#: index.docbook:658
+msgid "Enables autocommit for JDBC pooled connections (not recommended)."
+msgstr ""
+
+#: index.docbook:668
+msgid "hibernate.connection.release_mode"
+msgstr ""
+
+#: index.docbook:670
+msgid "Specify when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, you should use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr ""
+
+#: index.docbook:681
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr ""
+
+#: index.docbook:686
+msgid "Note that this setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See"
+msgstr ""
+
+#: index.docbook:698
+msgid "hibernate.connection.<emphasis><propertyName></emphasis>"
+msgstr ""
+
+#: index.docbook:700
+msgid "Pass the JDBC property <literal>propertyName</literal> to <literal>DriverManager.getConnection()</literal>."
+msgstr ""
+
+#: index.docbook:707
+msgid "hibernate.jndi.<emphasis><propertyName></emphasis>"
+msgstr ""
+
+#: index.docbook:709
+msgid "Pass the property <literal>propertyName</literal> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr ""
+
+#: index.docbook:719
+msgid "Hibernate Cache Properties"
+msgstr ""
+
+#: index.docbook:732
+msgid "hibernate.cache.provider_class"
+msgstr ""
+
+#: index.docbook:734
+msgid "The classname of a custom <literal>CacheProvider</literal>."
+msgstr ""
+
+#: index.docbook:736
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr ""
+
+#: index.docbook:744
+msgid "hibernate.cache.use_minimal_puts"
+msgstr ""
+
+#: index.docbook:746
+msgid "Optimize second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr ""
+
+#: index.docbook:759
+msgid "hibernate.cache.use_query_cache"
+msgstr ""
+
+#: index.docbook:761
+msgid "Enable the query cache, individual queries still have to be set cachable."
+msgstr ""
+
+#: index.docbook:771
+msgid "hibernate.cache.use_second_level_cache"
+msgstr ""
+
+#: index.docbook:773
+msgid "May be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal><cache></literal> mapping."
+msgstr ""
+
+#: index.docbook:785
+msgid "hibernate.cache.query_cache_factory"
+msgstr ""
+
+#: index.docbook:787
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr ""
+
+#: index.docbook:790
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr ""
+
+#: index.docbook:798
+msgid "hibernate.cache.region_prefix"
+msgstr ""
+
+#: index.docbook:800
+msgid "A prefix to use for second-level cache region names."
+msgstr ""
+
+#: index.docbook:802
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>prefix</literal>"
+msgstr ""
+
+#: index.docbook:810
+msgid "hibernate.cache.use_structured_entries"
+msgstr ""
+
+#: index.docbook:812
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
+msgstr ""
+
+#: index.docbook:826
+msgid "Hibernate Transaction Properties"
+msgstr ""
+
+#: index.docbook:839
+msgid "hibernate.transaction.factory_class"
+msgstr ""
+
+#: index.docbook:841
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr ""
+
+#: index.docbook:845
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr ""
+
+#: index.docbook:853
+msgid "jta.UserTransaction"
+msgstr ""
+
+#: index.docbook:855
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr ""
+
+#: index.docbook:867
+msgid "hibernate.transaction.manager_lookup_class"
+msgstr ""
+
+#: index.docbook:869
+msgid "The classname of a <literal>TransactionManagerLookup</literal> - required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr ""
+
+#: index.docbook:873
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr ""
+
+#: index.docbook:881
+msgid "hibernate.transaction.flush_before_completion"
+msgstr ""
+
+#: index.docbook:883
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:896
+msgid "hibernate.transaction.auto_close_session"
+msgstr ""
+
+#: index.docbook:898
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and utomatic session context management is preferred, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:914
+msgid "Miscellaneous Properties"
+msgstr ""
+
+#: index.docbook:927
+msgid "hibernate.current_session_context_class"
+msgstr ""
+
+#: index.docbook:929
+msgid "Supply a (custom) strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\"/> for more information about the built-in strategies."
+msgstr ""
+
+#: index.docbook:934
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr ""
+
+#: index.docbook:943
+msgid "hibernate.query.factory_class"
+msgstr ""
+
+#: index.docbook:945
+msgid "Chooses the HQL parser implementation."
+msgstr ""
+
+#: index.docbook:947
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr ""
+
+#: index.docbook:956
+msgid "hibernate.query.substitutions"
+msgstr ""
+
+#: index.docbook:958
+msgid "Mapping from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr ""
+
+#: index.docbook:961
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr ""
+
+#: index.docbook:969
+msgid "hibernate.hbm2ddl.auto"
+msgstr ""
+
+#: index.docbook:971
+msgid "Automatically validate or export schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr ""
+
+#: index.docbook:977
+msgid "<emphasis role=\"strong\">eg.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr ""
+
+#: index.docbook:986
+msgid "hibernate.cglib.use_reflection_optimizer"
+msgstr ""
+
+#: index.docbook:988
+msgid "Enables use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting, note that Hibernate always requires CGLIB even if you turn off the optimizer. You can not set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+
+#: index.docbook:1004
+msgid "SQL Dialects"
+msgstr ""
+
+#: index.docbook:1006
+msgid "You should always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above, saving you the effort of specifying them manually."
+msgstr ""
+
+#: index.docbook:1014
+msgid "Hibernate SQL Dialects (<literal>hibernate.dialect</literal>)"
+msgstr ""
+
+#: index.docbook:1022
+msgid "RDBMS"
+msgstr ""
+
+#: index.docbook:1023
+msgid "Dialect"
+msgstr ""
+
+#: index.docbook:1028
+msgid "<entry>DB2</entry>"
+msgstr ""
+
+#: index.docbook:1028
+msgid "org.hibernate.dialect.DB2Dialect"
+msgstr ""
+
+#: index.docbook:1031
+msgid "DB2 AS/400"
+msgstr ""
+
+#: index.docbook:1031
+msgid "org.hibernate.dialect.DB2400Dialect"
+msgstr ""
+
+#: index.docbook:1034
+msgid "DB2 OS390"
+msgstr ""
+
+#: index.docbook:1034
+msgid "org.hibernate.dialect.DB2390Dialect"
+msgstr ""
+
+#: index.docbook:1037
+msgid "PostgreSQL"
+msgstr ""
+
+#: index.docbook:1037
+msgid "org.hibernate.dialect.PostgreSQLDialect"
+msgstr ""
+
+#: index.docbook:1040
+msgid "MySQL"
+msgstr ""
+
+#: index.docbook:1040
+msgid "org.hibernate.dialect.MySQLDialect"
+msgstr ""
+
+#: index.docbook:1043
+msgid "MySQL with InnoDB"
+msgstr ""
+
+#: index.docbook:1043
+msgid "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr ""
+
+#: index.docbook:1046
+msgid "MySQL with MyISAM"
+msgstr ""
+
+#: index.docbook:1046
+msgid "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr ""
+
+#: index.docbook:1049
+msgid "Oracle (any version)"
+msgstr ""
+
+#: index.docbook:1049
+msgid "org.hibernate.dialect.OracleDialect"
+msgstr ""
+
+#: index.docbook:1052
+msgid "Oracle 9i/10g"
+msgstr ""
+
+#: index.docbook:1052
+msgid "org.hibernate.dialect.Oracle9Dialect"
+msgstr ""
+
+#: index.docbook:1055
+msgid "Sybase"
+msgstr ""
+
+#: index.docbook:1055
+msgid "org.hibernate.dialect.SybaseDialect"
+msgstr ""
+
+#: index.docbook:1058
+msgid "Sybase Anywhere"
+msgstr ""
+
+#: index.docbook:1058
+msgid "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr ""
+
+#: index.docbook:1061
+msgid "Microsoft SQL Server"
+msgstr ""
+
+#: index.docbook:1061
+msgid "org.hibernate.dialect.SQLServerDialect"
+msgstr ""
+
+#: index.docbook:1064
+msgid "SAP DB"
+msgstr ""
+
+#: index.docbook:1064
+msgid "org.hibernate.dialect.SAPDBDialect"
+msgstr ""
+
+#: index.docbook:1067
+msgid "Informix"
+msgstr ""
+
+#: index.docbook:1067
+msgid "org.hibernate.dialect.InformixDialect"
+msgstr ""
+
+#: index.docbook:1070
+msgid "HypersonicSQL"
+msgstr ""
+
+#: index.docbook:1070
+msgid "org.hibernate.dialect.HSQLDialect"
+msgstr ""
+
+#: index.docbook:1073
+msgid "Ingres"
+msgstr ""
+
+#: index.docbook:1073
+msgid "org.hibernate.dialect.IngresDialect"
+msgstr ""
+
+#: index.docbook:1076
+msgid "Progress"
+msgstr ""
+
+#: index.docbook:1076
+msgid "org.hibernate.dialect.ProgressDialect"
+msgstr ""
+
+#: index.docbook:1079
+msgid "Mckoi SQL"
+msgstr ""
+
+#: index.docbook:1079
+msgid "org.hibernate.dialect.MckoiDialect"
+msgstr ""
+
+#: index.docbook:1082
+msgid "Interbase"
+msgstr ""
+
+#: index.docbook:1082
+msgid "org.hibernate.dialect.InterbaseDialect"
+msgstr ""
+
+#: index.docbook:1085
+msgid "Pointbase"
+msgstr ""
+
+#: index.docbook:1085
+msgid "org.hibernate.dialect.PointbaseDialect"
+msgstr ""
+
+#: index.docbook:1088
+msgid "FrontBase"
+msgstr ""
+
+#: index.docbook:1088
+msgid "org.hibernate.dialect.FrontbaseDialect"
+msgstr ""
+
+#: index.docbook:1091
+msgid "Firebird"
+msgstr ""
+
+#: index.docbook:1091
+msgid "org.hibernate.dialect.FirebirdDialect"
+msgstr ""
+
+#: index.docbook:1100
+msgid "Outer Join Fetching"
+msgstr ""
+
+#: index.docbook:1102
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database (at the cost of possibly more work performed by the database itself). Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr ""
+
+#: index.docbook:1111
+msgid "Outer join fetching may be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations which have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr ""
+
+#: index.docbook:1119
+msgid "See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:1126
+msgid "Binary Streams"
+msgstr ""
+
+#: index.docbook:1128
+msgid "Oracle limits the size of <literal>byte</literal> arrays that may be passed to/from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr ""
+
+#: index.docbook:1139
+msgid "Second-level and query cache"
+msgstr ""
+
+#: index.docbook:1141
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\"/> for more details."
+msgstr ""
+
+#: index.docbook:1151
+msgid "Query Language Substitution"
+msgstr ""
+
+#: index.docbook:1153
+msgid "You may define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr ""
+
+#: index.docbook:1158
+msgid "hibernate.query.substitutions true=1, false=0"
+msgstr ""
+
+#: index.docbook:1160
+msgid "would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr ""
+
+#: index.docbook:1165
+msgid "hibernate.query.substitutions toLowercase=LOWER"
+msgstr ""
+
+#: index.docbook:1167
+msgid "would allow you to rename the SQL <literal>LOWER</literal> function."
+msgstr ""
+
+#: index.docbook:1174
+msgid "Hibernate statistics"
+msgstr ""
+
+#: index.docbook:1176
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate will expose a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr ""
+
+#: index.docbook:1188
+msgid "Logging"
+msgstr ""
+
+#: index.docbook:1190
+msgid "Hibernate logs various events using Apache commons-logging."
+msgstr ""
+
+#: index.docbook:1194
+msgid "The commons-logging service will direct output to either Apache Log4j (if you include <literal>log4j.jar</literal> in your classpath) or JDK1.4 logging (if running under JDK1.4 or above). You may download Log4j from <literal>http://jakarta.apache.org</literal>. To use Log4j you will need to place a <literal>log4j.properties</literal> file in your classpath, an example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr ""
+
+#: index.docbook:1204
+msgid "We strongly recommend that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr ""
+
+#: index.docbook:1213
+msgid "Hibernate Log Categories"
+msgstr ""
+
+#: index.docbook:1219
+msgid "Category"
+msgstr ""
+
+#: index.docbook:1220
+msgid "Function"
+msgstr ""
+
+#: index.docbook:1225
+msgid "org.hibernate.SQL"
+msgstr ""
+
+#: index.docbook:1226
+msgid "Log all SQL DML statements as they are executed"
+msgstr ""
+
+#: index.docbook:1229
+msgid "org.hibernate.type"
+msgstr ""
+
+#: index.docbook:1230
+msgid "Log all JDBC parameters"
+msgstr ""
+
+#: index.docbook:1233
+msgid "org.hibernate.tool.hbm2ddl"
+msgstr ""
+
+#: index.docbook:1234
+msgid "Log all SQL DDL statements as they are executed"
+msgstr ""
+
+#: index.docbook:1237
+msgid "org.hibernate.pretty"
+msgstr ""
+
+#: index.docbook:1238
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr ""
+
+#: index.docbook:1244
+msgid "org.hibernate.cache"
+msgstr ""
+
+#: index.docbook:1245
+msgid "Log all second-level cache activity"
+msgstr ""
+
+#: index.docbook:1248
+msgid "org.hibernate.transaction"
+msgstr ""
+
+#: index.docbook:1249
+msgid "Log transaction related activity"
+msgstr ""
+
+#: index.docbook:1252
+msgid "org.hibernate.jdbc"
+msgstr ""
+
+#: index.docbook:1253
+msgid "Log all JDBC resource acquisition"
+msgstr ""
+
+#: index.docbook:1256
+msgid "org.hibernate.hql.ast.AST"
+msgstr ""
+
+#: index.docbook:1257
+msgid "Log HQL and SQL ASTs during query parsing"
+msgstr ""
+
+#: index.docbook:1262
+msgid "org.hibernate.secure"
+msgstr ""
+
+#: index.docbook:1263
+msgid "Log all JAAS authorization requests"
+msgstr ""
+
+#: index.docbook:1266
+msgid "org.hibernate"
+msgstr ""
+
+#: index.docbook:1267
+msgid "Log everything (a lot of information, but very useful for troubleshooting)"
+msgstr ""
+
+#: index.docbook:1276
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr ""
+
+#: index.docbook:1286
+msgid "Implementing a <literal>NamingStrategy</literal>"
+msgstr ""
+
+#: index.docbook:1288
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr ""
+
+#: index.docbook:1293
+msgid "You may provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr ""
+
+#: index.docbook:1302
+msgid "You may specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr ""
+
+#: index.docbook:1307
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
+ " .addFile(\"Item.hbm.xml\")\n"
+ " .addFile(\"Bid.hbm.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1309
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr ""
+
+#: index.docbook:1317
+msgid "XML configuration file"
+msgstr ""
+
+#: index.docbook:1319
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr ""
+
+#: index.docbook:1326
+msgid "The XML configuration file is by default expected to be in the root o your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr ""
+
+#: index.docbook:1331
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <!-- a SessionFactory instance listed as /jndi/name -->\n"
+ " <session-factory\n"
+ " name=\"java:hibernate/SessionFactory\">\n"
+ "\n"
+ " <!-- properties -->\n"
+ " <property name=\"connection.datasource\">java:/comp/env/jdbc/MyDB</property>\n"
+ " <property name=\"dialect\">org.hibernate.dialect.MySQLDialect</property>\n"
+ " <property name=\"show_sql\">false</property>\n"
+ " <property name=\"transaction.factory_class\">\n"
+ " org.hibernate.transaction.JTATransactionFactory\n"
+ " </property>\n"
+ " <property name=\"jta.UserTransaction\">java:comp/UserTransaction</property>\n"
+ "\n"
+ " <!-- mapping files -->\n"
+ " <mapping resource=\"org/hibernate/auction/Item.hbm.xml\"/>\n"
+ " <mapping resource=\"org/hibernate/auction/Bid.hbm.xml\"/>\n"
+ "\n"
+ " <!-- cache settings -->\n"
+ " <class-cache class=\"org.hibernate.auction.Item\" usage=\"read-write\"/>\n"
+ " <class-cache class=\"org.hibernate.auction.Bid\" usage=\"read-only\"/>\n"
+ " <collection-cache collection=\"org.hibernate.auction.Item.bids\" usage=\"read-write\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:1333
+msgid "As you can see, the advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. Note that is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>, both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr ""
+
+#: index.docbook:1342
+msgid "With the XML configuration, starting Hibernate is then as simple as"
+msgstr ""
+
+#: index.docbook:1346
+msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1348
+msgid "You can pick a different XML configuration file using"
+msgstr ""
+
+#: index.docbook:1352
+msgid ""
+ "<![CDATA[SessionFactory sf = new Configuration()\n"
+ " .configure(\"catdb.cfg.xml\")\n"
+ " .buildSessionFactory();]]>"
+msgstr ""
+
+#: index.docbook:1357
+msgid "J2EE Application Server integration"
+msgstr ""
+
+#: index.docbook:1359
+msgid "Hibernate has the following integration points for J2EE infrastructure:"
+msgstr ""
+
+#: index.docbook:1365
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), esp. distributed transaction handling across several datasources. You may of course also demarcate transaction boundaries programmatically (BMT) or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr ""
+
+#: index.docbook:1380
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr ""
+
+#: index.docbook:1389
+msgid "<emphasis>JTA Session binding:</emphasis> The Hibernate <literal>Session</literal> may be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate take care of flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr ""
+
+#: index.docbook:1402
+msgid "<emphasis>JMX deployment:</emphasis> If you have a JMX capable application server (e.g. JBoss AS), you can chose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal>, and ideally also take care of service dependencies (Datasource has to be available before Hibernate starts, etc)."
+msgstr ""
+
+#: index.docbook:1413
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr ""
+
+#: index.docbook:1420
+msgid "Transaction strategy configuration"
+msgstr ""
+
+#: index.docbook:1422
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly, through a connection pool, you may begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr ""
+
+#: index.docbook:1430
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr ""
+
+#: index.docbook:1437
+msgid "There are three standard (built-in) choices:"
+msgstr ""
+
+#: index.docbook:1443
+msgid "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr ""
+
+#: index.docbook:1445
+msgid "delegates to database (JDBC) transactions (default)"
+msgstr ""
+
+#: index.docbook:1449
+msgid "org.hibernate.transaction.JTATransactionFactory"
+msgstr ""
+
+#: index.docbook:1451
+msgid "delegates to container-managed transaction if an existing transaction is underway in this context (e.g. EJB session bean method), otherwise a new transaction is started and bean-managed transaction are used."
+msgstr ""
+
+#: index.docbook:1459
+msgid "org.hibernate.transaction.CMTTransactionFactory"
+msgstr ""
+
+#: index.docbook:1461
+msgid "delegates to container-managed JTA transactions"
+msgstr ""
+
+#: index.docbook:1466
+msgid "You may also define your own transaction strategies (for a CORBA transaction service, for example)."
+msgstr ""
+
+#: index.docbook:1471
+msgid "Some features in Hibernate (i.e. the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>, since J2EE does not standardize a single mechanism:"
+msgstr ""
+
+#: index.docbook:1479
+msgid "JTA TransactionManagers"
+msgstr ""
+
+#: index.docbook:1485
+msgid "Transaction Factory"
+msgstr ""
+
+#: index.docbook:1486
+msgid "Application Server"
+msgstr ""
+
+#: index.docbook:1491
+msgid "org.hibernate.transaction.JBossTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1492
+msgid "JBoss"
+msgstr ""
+
+#: index.docbook:1495
+msgid "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1496
+msgid "Weblogic"
+msgstr ""
+
+#: index.docbook:1499
+msgid "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1500
+msgid "WebSphere"
+msgstr ""
+
+#: index.docbook:1503
+msgid "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+msgstr ""
+
+#: index.docbook:1504
+msgid "WebSphere 6"
+msgstr ""
+
+#: index.docbook:1507
+msgid "org.hibernate.transaction.OrionTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1508
+msgid "Orion"
+msgstr ""
+
+#: index.docbook:1511
+msgid "org.hibernate.transaction.ResinTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1512
+msgid "Resin"
+msgstr ""
+
+#: index.docbook:1515
+msgid "org.hibernate.transaction.JOTMTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1516
+msgid "JOTM"
+msgstr ""
+
+#: index.docbook:1519
+msgid "org.hibernate.transaction.JOnASTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1520
+msgid "JOnAS"
+msgstr ""
+
+#: index.docbook:1523
+msgid "org.hibernate.transaction.JRun4TransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1524
+msgid "JRun4"
+msgstr ""
+
+#: index.docbook:1527
+msgid "org.hibernate.transaction.BESTransactionManagerLookup"
+msgstr ""
+
+#: index.docbook:1528
+msgid "Borland ES"
+msgstr ""
+
+#: index.docbook:1537
+msgid "JNDI-bound <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:1539
+msgid "A JNDI bound Hibernate <literal>SessionFactory</literal> can simplify the lookup of the factory and the creation of new <literal>Session</literal>s. Note that this is not related to a JNDI bound <literal>Datasource</literal>, both simply use the same registry!"
+msgstr ""
+
+#: index.docbook:1546
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (eg. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. (This is especially useful in environments with a read-only JNDI default implementation, e.g. Tomcat.)"
+msgstr ""
+
+#: index.docbook:1554
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr ""
+
+#: index.docbook:1561
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will at least have this call in some startup code (or utility class) in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (discussed later)."
+msgstr ""
+
+#: index.docbook:1568
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class may obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr ""
+
+#: index.docbook:1573
+msgid "We recommend that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate—see chapter 1."
+msgstr ""
+
+#: index.docbook:1585
+msgid "Current Session context management with JTA"
+msgstr ""
+
+#: index.docbook:1587
+msgid "The easiest way to handle <literal>Session</literal>s and transactions is Hibernates automatic \"current\" <literal>Session</literal> management. See the discussion of <xref linkend=\"architecture-current-session\"/>current sessions. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in <literal>\"jta\"</literal> context will be set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of such man!
agement concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr ""
+
+#: index.docbook:1610
+msgid "JMX deployment"
+msgstr ""
+
+#: index.docbook:1612
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block (like the one in <literal>HibernateUtil</literal>) or you deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr ""
+
+#: index.docbook:1620
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr ""
+
+#: index.docbook:1627
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<server>\n"
+ "\n"
+ "<mbean code=\"org.hibernate.jmx.HibernateService\"\n"
+ " name=\"jboss.jca:service=HibernateFactory,name=HibernateFactory\">\n"
+ "\n"
+ " <!-- Required services -->\n"
+ " <depends>jboss.jca:service=RARDeployer</depends>\n"
+ " <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>\n"
+ "\n"
+ " <!-- Bind the Hibernate service to JNDI -->\n"
+ " <attribute name=\"JndiName\">java:/hibernate/SessionFactory</attribute>\n"
+ "\n"
+ " <!-- Datasource settings -->\n"
+ " <attribute name=\"Datasource\">java:HsqlDS</attribute>\n"
+ " <attribute name=\"Dialect\">org.hibernate.dialect.HSQLDialect</attribute>\n"
+ "\n"
+ " <!-- Transaction integration -->\n"
+ " <attribute name=\"TransactionStrategy\">\n"
+ " org.hibernate.transaction.JTATransactionFactory</attribute>\n"
+ " <attribute name=\"TransactionManagerLookupStrategy\">\n"
+ " org.hibernate.transaction.JBossTransactionManagerLookup</attribute>\n"
+ " <attribute name=\"FlushBeforeCompletionEnabled\">true</attribute>\n"
+ " <attribute name=\"AutoCloseSessionEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Fetching options -->\n"
+ " <attribute name=\"MaximumFetchDepth\">5</attribute>\n"
+ "\n"
+ " <!-- Second-level caching -->\n"
+ " <attribute name=\"SecondLevelCacheEnabled\">true</attribute>\n"
+ " <attribute name=\"CacheProviderClass\">org.hibernate.cache.EhCacheProvider</attribute>\n"
+ " <attribute name=\"QueryCacheEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Logging -->\n"
+ " <attribute name=\"ShowSqlEnabled\">true</attribute>\n"
+ "\n"
+ " <!-- Mapping files -->\n"
+ " <attribute name=\"MapResources\">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>\n"
+ "\n"
+ "</mbean>\n"
+ "\n"
+ "</server>]]>"
+msgstr ""
+
+#: index.docbook:1629
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) may be kept in their own JAR file, but you may include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/events.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/events.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/events.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,245 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Interceptors and events"
+msgstr ""
+
+#: index.docbook:7
+msgid "It is often useful for the application to react to certain events that occur inside Hibernate. This allows implementation of certain kinds of generic functionality, and extension of Hibernate functionality."
+msgstr ""
+
+#: index.docbook:14
+msgid "Interceptors"
+msgstr ""
+
+#: index.docbook:16
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr ""
+
+#: index.docbook:27
+msgid "You may either implement <literal>Interceptor</literal> directly or (better) extend <literal>EmptyInterceptor</literal>."
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[package org.hibernate.test;\n"
+ "\n"
+ "import java.io.Serializable;\n"
+ "import java.util.Date;\n"
+ "import java.util.Iterator;\n"
+ "\n"
+ "import org.hibernate.EmptyInterceptor;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.type.Type;\n"
+ "\n"
+ "public class AuditInterceptor extends EmptyInterceptor {\n"
+ "\n"
+ " private int updates;\n"
+ " private int creates;\n"
+ " private int loads;\n"
+ "\n"
+ " public void onDelete(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " // do nothing\n"
+ " }\n"
+ "\n"
+ " public boolean onFlushDirty(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] currentState,\n"
+ " Object[] previousState,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " updates++;\n"
+ " for ( int i=0; i < propertyNames.length; i++ ) {\n"
+ " if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " currentState[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onLoad(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " loads++;\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public boolean onSave(Object entity,\n"
+ " Serializable id,\n"
+ " Object[] state,\n"
+ " String[] propertyNames,\n"
+ " Type[] types) {\n"
+ "\n"
+ " if ( entity instanceof Auditable ) {\n"
+ " creates++;\n"
+ " for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
+ " state[i] = new Date();\n"
+ " return true;\n"
+ " }\n"
+ " }\n"
+ " }\n"
+ " return false;\n"
+ " }\n"
+ "\n"
+ " public void afterTransactionCompletion(Transaction tx) {\n"
+ " if ( tx.wasCommitted() ) {\n"
+ " System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
+ " }\n"
+ " updates=0;\n"
+ " creates=0;\n"
+ " loads=0;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "Interceptors come in two flavors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr ""
+
+#: index.docbook:39
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr ""
+
+#: index.docbook:45
+msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
+msgstr ""
+
+#: index.docbook:47
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. In this case, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>; this is true unless a session is opened explicitly specifying the interceptor to use. <literal>SessionFactory</literal>-scoped interceptors must be thread safe, taking care to not store session-specific state since multiple sessions will use this interceptor (potentially) concurrently."
+msgstr ""
+
+#: index.docbook:56
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Event system"
+msgstr ""
+
+#: index.docbook:63
+msgid "If you have to react to particular events in your persistence layer, you may also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition or as a replacement for interceptors."
+msgstr ""
+
+#: index.docbook:69
+msgid "Essentially all of the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc (consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types). When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implemenation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:84
+msgid "The listeners should be considered effectively singletons; meaning, they are shared between requests, and thus should not save any state as instance variables."
+msgstr ""
+
+#: index.docbook:89
+msgid "A custom listener should implement the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML (declarative configuration through the properties file is not supported). Here's an example of a custom load event listener:"
+msgstr ""
+
+#: index.docbook:99
+msgid ""
+ "<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
+ " // this is the single method defined by the LoadEventListener interface\n"
+ " public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
+ " throws HibernateException {\n"
+ " if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
+ " throw MySecurityException(\"Unauthorized access\");\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:101
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr ""
+
+#: index.docbook:106
+msgid ""
+ "<![CDATA[<hibernate-configuration>\n"
+ " <session-factory>\n"
+ " ...\n"
+ " <event type=\"load\">\n"
+ " <listener class=\"com.eg.MyLoadListener\"/>\n"
+ " <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+ " </event>\n"
+ " </session-factory>\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:108
+msgid "Instead, you may register it programmatically:"
+msgstr ""
+
+#: index.docbook:112
+msgid ""
+ "<![CDATA[Configuration cfg = new Configuration();\n"
+ "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+ "cfg.EventListeners().setLoadEventListeners(stack);]]>"
+msgstr ""
+
+#: index.docbook:114
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need the capability to share listener instances between listener types you must use the programmatic registration approach."
+msgstr ""
+
+#: index.docbook:122
+msgid "Why implement an interface and define the specific type during configuration? Well, a listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr ""
+
+#: index.docbook:132
+msgid "Hibernate declarative security"
+msgstr ""
+
+#: index.docbook:133
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Now, Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is optional functionality built on top of the event architecture."
+msgstr ""
+
+#: index.docbook:139
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr ""
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+ "<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+ "<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+ "<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
+msgstr ""
+
+#: index.docbook:146
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is just a shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr ""
+
+#: index.docbook:152
+msgid "Next, still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr ""
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+ "<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
+msgstr ""
+
+#: index.docbook:158
+msgid "The role names are the roles understood by your JACC provider."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/example_mappings.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/example_mappings.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/example_mappings.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,653 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Example: Various Mappings"
+msgstr ""
+
+#: index.docbook:22
+msgid "This chapters shows off some more complex association mappings."
+msgstr ""
+
+#: index.docbook:27
+msgid "Employer/Employee"
+msgstr ""
+
+#: index.docbook:29
+msgid "The following model of the relationship between <literal>Employer</literal> and <literal>Employee</literal> uses an actual entity class (<literal>Employment</literal>) to represent the association. This is done because there might be more than one period of employment for the same two parties. Components are used to model monetary values and employee names."
+msgstr ""
+
+#: index.docbook:46
+msgid "Heres a possible mapping document:"
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " \n"
+ " <class name=\"Employer\" table=\"employers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employer_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employment\" table=\"employment_periods\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employment_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"startDate\" column=\"start_date\"/>\n"
+ " <property name=\"endDate\" column=\"end_date\"/>\n"
+ "\n"
+ " <component name=\"hourlyRate\" class=\"MonetaryAmount\">\n"
+ " <property name=\"amount\">\n"
+ " <column name=\"hourly_rate\" sql-type=\"NUMERIC(12, 2)\"/>\n"
+ " </property>\n"
+ " <property name=\"currency\" length=\"12\"/>\n"
+ " </component>\n"
+ "\n"
+ " <many-to-one name=\"employer\" column=\"employer_id\" not-null=\"true\"/>\n"
+ " <many-to-one name=\"employee\" column=\"employee_id\" not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Employee\" table=\"employees\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"sequence\">\n"
+ " <param name=\"sequence\">employee_id_seq</param>\n"
+ " </generator>\n"
+ " </id>\n"
+ " <property name=\"taxfileNumber\"/>\n"
+ " <component name=\"name\" class=\"Name\">\n"
+ " <property name=\"firstName\"/>\n"
+ " <property name=\"initial\"/>\n"
+ " <property name=\"lastName\"/>\n"
+ " </component>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:52
+msgid "And heres the table schema generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: index.docbook:56
+msgid ""
+ "<![CDATA[create table employers (\n"
+ " id BIGINT not null, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employment_periods (\n"
+ " id BIGINT not null,\n"
+ " hourly_rate NUMERIC(12, 2),\n"
+ " currency VARCHAR(12), \n"
+ " employee_id BIGINT not null, \n"
+ " employer_id BIGINT not null, \n"
+ " end_date TIMESTAMP, \n"
+ " start_date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table employees (\n"
+ " id BIGINT not null, \n"
+ " firstName VARCHAR(255), \n"
+ " initial CHAR(1), \n"
+ " lastName VARCHAR(255), \n"
+ " taxfileNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK0 foreign key (employer_id) references employers\n"
+ "alter table employment_periods \n"
+ " add constraint employment_periodsFK1 foreign key (employee_id) references employees\n"
+ "create sequence employee_id_seq\n"
+ "create sequence employment_id_seq\n"
+ "create sequence employer_id_seq]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Author/Work"
+msgstr ""
+
+#: index.docbook:63
+msgid "Consider the following model of the relationships between <literal>Work</literal>, <literal>Author</literal> and <literal>Person</literal>. We represent the relationship between <literal>Work</literal> and <literal>Author</literal> as a many-to-many association. We choose to represent the relationship between <literal>Author</literal> and <literal>Person</literal> as one-to-one association. Another possibility would be to have <literal>Author</literal> extend <literal>Person</literal>."
+msgstr ""
+
+#: index.docbook:81
+msgid "The following mapping document correctly represents these relationships:"
+msgstr ""
+
+#: index.docbook:85
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Work\" table=\"works\" discriminator-value=\"W\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"type\" type=\"character\"/>\n"
+ "\n"
+ " <property name=\"title\"/>\n"
+ " <set name=\"authors\" table=\"author_work\">\n"
+ " <key column name=\"work_id\"/>\n"
+ " <many-to-many class=\"Author\" column name=\"author_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " <subclass name=\"Book\" discriminator-value=\"B\">\n"
+ " <property name=\"text\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " <subclass name=\"Song\" discriminator-value=\"S\">\n"
+ " <property name=\"tempo\"/>\n"
+ " <property name=\"genre\"/>\n"
+ " </subclass>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Author\" table=\"authors\">\n"
+ "\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <!-- The Author must have the same identifier as the Person -->\n"
+ " <generator class=\"assigned\"/> \n"
+ " </id>\n"
+ "\n"
+ " <property name=\"alias\"/>\n"
+ " <one-to-one name=\"person\" constrained=\"true\"/>\n"
+ "\n"
+ " <set name=\"works\" table=\"author_work\" inverse=\"true\">\n"
+ " <key column=\"author_id\"/>\n"
+ " <many-to-many class=\"Work\" column=\"work_id\"/>\n"
+ " </set>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Person\" table=\"persons\">\n"
+ " <id name=\"id\" column=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:87
+msgid "There are four tables in this mapping. <literal>works</literal>, <literal>authors</literal> and <literal>persons</literal> hold work, author and person data respectively. <literal>author_work</literal> is an association table linking authors to works. Heres the table schema, as generated by <literal>SchemaExport</literal>."
+msgstr ""
+
+#: index.docbook:95
+msgid ""
+ "<![CDATA[create table works (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " tempo FLOAT, \n"
+ " genre VARCHAR(255), \n"
+ " text INTEGER, \n"
+ " title VARCHAR(255), \n"
+ " type CHAR(1) not null, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table author_work (\n"
+ " author_id BIGINT not null, \n"
+ " work_id BIGINT not null, \n"
+ " primary key (work_id, author_id)\n"
+ ")\n"
+ "\n"
+ "create table authors (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " alias VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table persons (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table authors \n"
+ " add constraint authorsFK0 foreign key (id) references persons\n"
+ "alter table author_work \n"
+ " add constraint author_workFK0 foreign key (author_id) references authors\n"
+ "alter table author_work\n"
+ " add constraint author_workFK1 foreign key (work_id) references works]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "Customer/Order/Product"
+msgstr ""
+
+#: index.docbook:102
+msgid "Now consider a model of the relationships between <literal>Customer</literal>, <literal>Order</literal> and <literal>LineItem</literal> and <literal>Product</literal>. There is a one-to-many association between <literal>Customer</literal> and <literal>Order</literal>, but how should we represent <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? I've chosen to map <literal>LineItem</literal> as an association class representing the many-to-many association between <literal>Order</literal> and <literal>Product</literal>. In Hibernate, this is called a composite element."
+msgstr ""
+
+#: index.docbook:122
+msgid "The mapping document:"
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"Customer\" table=\"customers\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\"/>\n"
+ " <set name=\"orders\" inverse=\"true\">\n"
+ " <key column=\"customer_id\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </set>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Order\" table=\"orders\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\"/>\n"
+ " <many-to-one name=\"customer\" column=\"customer_id\"/>\n"
+ " <list name=\"lineItems\" table=\"line_items\">\n"
+ " <key column=\"order_id\"/>\n"
+ " <list-index column=\"line_number\"/>\n"
+ " <composite-element class=\"LineItem\">\n"
+ " <property name=\"quantity\"/>\n"
+ " <many-to-one name=\"product\" column=\"product_id\"/>\n"
+ " </composite-element>\n"
+ " </list>\n"
+ " </class>\n"
+ "\n"
+ " <class name=\"Product\" table=\"products\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"serialNumber\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "<literal>customers</literal>, <literal>orders</literal>, <literal>line_items</literal> and <literal>products</literal> hold customer, order, order line item and product data respectively. <literal>line_items</literal> also acts as an association table linking orders with products."
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[create table customers (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " name VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table orders (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " customer_id BIGINT, \n"
+ " date TIMESTAMP, \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "create table line_items (\n"
+ " line_number INTEGER not null, \n"
+ " order_id BIGINT not null, \n"
+ " product_id BIGINT, \n"
+ " quantity INTEGER, \n"
+ " primary key (order_id, line_number)\n"
+ ")\n"
+ "\n"
+ "create table products (\n"
+ " id BIGINT not null generated by default as identity, \n"
+ " serialNumber VARCHAR(255), \n"
+ " primary key (id)\n"
+ ")\n"
+ "\n"
+ "alter table orders \n"
+ " add constraint ordersFK0 foreign key (customer_id) references customers\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK0 foreign key (product_id) references products\n"
+ "alter table line_items\n"
+ " add constraint line_itemsFK1 foreign key (order_id) references orders]]>"
+msgstr ""
+
+#: index.docbook:140
+msgid "Miscellaneous example mappings"
+msgstr ""
+
+#: index.docbook:142
+msgid "These examples are all taken from the Hibernate test suite. You will find many other useful example mappings there. Look in the <literal>test</literal> folder of the Hibernate distribution."
+msgstr ""
+
+#: index.docbook:148
+msgid "TODO: put words around this stuff"
+msgstr ""
+
+#: index.docbook:151
+msgid "\"Typed\" one-to-one association"
+msgstr ""
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"name\"/>\n"
+ " <one-to-one name=\"address\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'HOME'</formula>\n"
+ " </one-to-one>\n"
+ " <one-to-one name=\"mailingAddress\" \n"
+ " cascade=\"all\">\n"
+ " <formula>name</formula>\n"
+ " <formula>'MAILING'</formula>\n"
+ " </one-to-one>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\" batch-size=\"2\" \n"
+ " check=\"addressType in ('MAILING', 'HOME', 'BUSINESS')\">\n"
+ " <composite-id>\n"
+ " <key-many-to-one name=\"person\" \n"
+ " column=\"personName\"/>\n"
+ " <key-property name=\"type\" \n"
+ " column=\"addressType\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"street\" type=\"text\"/>\n"
+ " <property name=\"state\"/>\n"
+ " <property name=\"zip\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "Composite key example"
+msgstr ""
+
+#: index.docbook:157
+msgid ""
+ "<![CDATA[<class name=\"Customer\">\n"
+ "\n"
+ " <id name=\"customerId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\" not-null=\"true\" length=\"100\"/>\n"
+ " <property name=\"address\" not-null=\"true\" length=\"200\"/>\n"
+ "\n"
+ " <list name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key column=\"customerId\"/>\n"
+ " <index column=\"orderNumber\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </list>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Order\" table=\"CustomerOrder\" lazy=\"true\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ " <synchronize table=\"Product\"/>\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"Order$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"orderDate\" \n"
+ " type=\"calendar_date\"\n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <property name=\"total\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity*p.price) \n"
+ " from LineItem li, Product p \n"
+ " where li.productId = p.productId \n"
+ " and li.customerId = customerId \n"
+ " and li.orderNumber = orderNumber )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ " <many-to-one name=\"customer\"\n"
+ " column=\"customerId\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"/>\n"
+ " \n"
+ " <bag name=\"lineItems\"\n"
+ " fetch=\"join\" \n"
+ " inverse=\"true\"\n"
+ " cascade=\"save-update\">\n"
+ " <key>\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </key>\n"
+ " <one-to-many class=\"LineItem\"/>\n"
+ " </bag>\n"
+ " \n"
+ "</class>\n"
+ " \n"
+ "<class name=\"LineItem\">\n"
+ " \n"
+ " <composite-id name=\"id\" \n"
+ " class=\"LineItem$Id\">\n"
+ " <key-property name=\"customerId\" length=\"10\"/>\n"
+ " <key-property name=\"orderNumber\"/>\n"
+ " <key-property name=\"productId\" length=\"10\"/>\n"
+ " </composite-id>\n"
+ " \n"
+ " <property name=\"quantity\"/>\n"
+ " \n"
+ " <many-to-one name=\"order\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\">\n"
+ " <column name=\"customerId\"/>\n"
+ " <column name=\"orderNumber\"/>\n"
+ " </many-to-one>\n"
+ " \n"
+ " <many-to-one name=\"product\"\n"
+ " insert=\"false\"\n"
+ " update=\"false\" \n"
+ " not-null=\"true\"\n"
+ " column=\"productId\"/>\n"
+ " \n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Product\">\n"
+ " <synchronize table=\"LineItem\"/>\n"
+ "\n"
+ " <id name=\"productId\"\n"
+ " length=\"10\">\n"
+ " <generator class=\"assigned\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"description\" \n"
+ " not-null=\"true\" \n"
+ " length=\"200\"/>\n"
+ " <property name=\"price\" length=\"3\"/>\n"
+ " <property name=\"numberAvailable\"/>\n"
+ " \n"
+ " <property name=\"numberOrdered\">\n"
+ " <formula>\n"
+ " ( select sum(li.quantity) \n"
+ " from LineItem li \n"
+ " where li.productId = productId )\n"
+ " </formula>\n"
+ " </property>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:161
+msgid "Many-to-many with shared composite key attribute"
+msgstr ""
+
+#: index.docbook:162
+msgid ""
+ "<![CDATA[<class name=\"User\" table=\"`User`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <set name=\"groups\" table=\"UserGroup\">\n"
+ " <key>\n"
+ " <column name=\"userName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"Group\">\n"
+ " <column name=\"groupName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ " \n"
+ "<class name=\"Group\" table=\"`Group`\">\n"
+ " <composite-id>\n"
+ " <key-property name=\"name\"/>\n"
+ " <key-property name=\"org\"/>\n"
+ " </composite-id>\n"
+ " <property name=\"description\"/>\n"
+ " <set name=\"users\" table=\"UserGroup\" inverse=\"true\">\n"
+ " <key>\n"
+ " <column name=\"groupName\"/>\n"
+ " <column name=\"org\"/>\n"
+ " </key>\n"
+ " <many-to-many class=\"User\">\n"
+ " <column name=\"userName\"/>\n"
+ " <formula>org</formula>\n"
+ " </many-to-many>\n"
+ " </set>\n"
+ "</class>\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:166
+msgid "Content based discrimination"
+msgstr ""
+
+#: index.docbook:167
+msgid ""
+ "<![CDATA[<class name=\"Person\"\n"
+ " discriminator-value=\"P\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"person_id\" \n"
+ " unsaved-value=\"0\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " \n"
+ " \n"
+ " <discriminator \n"
+ " type=\"character\">\n"
+ " <formula>\n"
+ " case \n"
+ " when title is not null then 'E' \n"
+ " when salesperson is not null then 'C' \n"
+ " else 'P' \n"
+ " end\n"
+ " </formula>\n"
+ " </discriminator>\n"
+ "\n"
+ " <property name=\"name\" \n"
+ " not-null=\"true\"\n"
+ " length=\"80\"/>\n"
+ " \n"
+ " <property name=\"sex\" \n"
+ " not-null=\"true\"\n"
+ " update=\"false\"/>\n"
+ " \n"
+ " <component name=\"address\">\n"
+ " <property name=\"address\"/>\n"
+ " <property name=\"zip\"/>\n"
+ " <property name=\"country\"/>\n"
+ " </component>\n"
+ " \n"
+ " <subclass name=\"Employee\" \n"
+ " discriminator-value=\"E\">\n"
+ " <property name=\"title\"\n"
+ " length=\"20\"/>\n"
+ " <property name=\"salary\"/>\n"
+ " <many-to-one name=\"manager\"/>\n"
+ " </subclass>\n"
+ " \n"
+ " <subclass name=\"Customer\" \n"
+ " discriminator-value=\"C\">\n"
+ " <property name=\"comments\"/>\n"
+ " <many-to-one name=\"salesperson\"/>\n"
+ " </subclass>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:171
+msgid "Associations on alternate keys"
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " \n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ " \n"
+ " <property name=\"name\" length=\"100\"/>\n"
+ " \n"
+ " <one-to-one name=\"address\" \n"
+ " property-ref=\"person\"\n"
+ " cascade=\"all\"\n"
+ " fetch=\"join\"/>\n"
+ " \n"
+ " <set name=\"accounts\" \n"
+ " inverse=\"true\">\n"
+ " <key column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " <one-to-many class=\"Account\"/>\n"
+ " </set>\n"
+ " \n"
+ " <property name=\"userId\" length=\"8\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Address\">\n"
+ "\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"hilo\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"address\" length=\"300\"/>\n"
+ " <property name=\"zip\" length=\"5\"/>\n"
+ " <property name=\"country\" length=\"25\"/>\n"
+ " <many-to-one name=\"person\" unique=\"true\" not-null=\"true\"/>\n"
+ "\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Account\">\n"
+ " <id name=\"accountId\" length=\"32\">\n"
+ " <generator class=\"uuid\"/>\n"
+ " </id>\n"
+ " \n"
+ " <many-to-one name=\"user\"\n"
+ " column=\"userId\"\n"
+ " property-ref=\"userId\"/>\n"
+ " \n"
+ " <property name=\"type\" not-null=\"true\"/>\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/example_parentchild.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/example_parentchild.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/example_parentchild.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,287 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Parent/Child"
+msgstr ""
+
+#: index.docbook:7
+msgid "One of the very first things that new users try to do with Hibernate is to model a parent / child type relationship. There are two different approaches to this. For various reasons the most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal><composite-element></literal>.) Now, it turns out that default semantics of a one to many association (in Hibernate) are much less close to the usual semantics of a parent / child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one to many association with cascades</emphasis> to model a parent / child relationship efficiently and elegantly. It's not at all difficult!"
+msgstr ""
+
+#: index.docbook:21
+msgid "A note about collections"
+msgstr ""
+
+#: index.docbook:23
+msgid "Hibernate collections are considered to be a logical part of their owning entity; never of the contained entities. This is a crucial distinction! It has the following consequences:"
+msgstr ""
+
+#: index.docbook:30
+msgid "When we remove / add an object from / to a collection, the version number of the collection owner is incremented."
+msgstr ""
+
+#: index.docbook:36
+msgid "If an object that was removed from a collection is an instance of a value type (eg, a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr ""
+
+#: index.docbook:44
+msgid "On the other hand, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted, by default. This behaviour is completely consistent - a change to the internal state of another entity should not cause the associated entity to vanish! Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr ""
+
+#: index.docbook:54
+msgid "Instead, the default behaviour is that adding an entity to a collection merely creates a link between the two entities, while removing it removes the link. This is very appropriate for all sorts of cases. Where it is not appropriate at all is the case of a parent / child relationship, where the life of the child is bound to the life cycle of the parent."
+msgstr ""
+
+#: index.docbook:64
+msgid "Bidirectional one-to-many"
+msgstr ""
+
+#: index.docbook:66
+msgid "Suppose we start with a simple <literal><one-to-many></literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr ""
+
+#: index.docbook:71
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:73
+msgid "If we were to execute the following code"
+msgstr ""
+
+#: index.docbook:77
+msgid ""
+ "<![CDATA[Parent p = .....;\n"
+ "Child c = new Child();\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:79
+msgid "Hibernate would issue two SQL statements:"
+msgstr ""
+
+#: index.docbook:85
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr ""
+
+#: index.docbook:88
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr ""
+
+#: index.docbook:95
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. We can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr ""
+
+#: index.docbook:101
+msgid ""
+ "<![CDATA[<set name=\"children\">\n"
+ " <key column=\"parent_id\" not-null=\"true\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:103
+msgid "However, this is not the recommended solution."
+msgstr ""
+
+#: index.docbook:106
+msgid "The underlying cause of this behaviour is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. So the solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr ""
+
+#: index.docbook:113
+msgid "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true\"/>]]>"
+msgstr ""
+
+#: index.docbook:115
+msgid "(We also need to add the <literal>parent</literal> property to the <literal>Child</literal> class.)"
+msgstr ""
+
+#: index.docbook:119
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute."
+msgstr ""
+
+#: index.docbook:124
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:126
+msgid "The following code would be used to add a new <literal>Child</literal>"
+msgstr ""
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:132
+msgid "And now, only one SQL <literal>INSERT</literal> would be issued!"
+msgstr ""
+
+#: index.docbook:136
+msgid "To tighten things up a bit, we could create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr ""
+
+#: index.docbook:141
+msgid ""
+ "<![CDATA[public void addChild(Child c) {\n"
+ " c.setParent(this);\n"
+ " children.add(c);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:143
+msgid "Now, the code to add a <literal>Child</literal> looks like"
+msgstr ""
+
+#: index.docbook:147
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.save(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:152
+msgid "Cascading life cycle"
+msgstr ""
+
+#: index.docbook:154
+msgid "The explicit call to <literal>save()</literal> is still annoying. We will address this by using cascades."
+msgstr ""
+
+#: index.docbook:159
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:161
+msgid "This simplifies the code above to"
+msgstr ""
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = new Child();\n"
+ "p.addChild(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:167
+msgid "Similarly, we don't need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "session.delete(p);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid "However, this code"
+msgstr ""
+
+#: index.docbook:178
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "c.setParent(null);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:180
+msgid "will not remove <literal>c</literal> from the database; it will ony remove the link to <literal>p</literal> (and cause a <literal>NOT NULL</literal> constraint violation, in this case). You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
+ "Child c = (Child) p.getChildren().iterator().next();\n"
+ "p.getChildren().remove(c);\n"
+ "session.delete(c);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "Now, in our case, a <literal>Child</literal> can't really exist without its parent. So if we remove a <literal>Child</literal> from the collection, we really do want it to be deleted. For this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr ""
+
+#: index.docbook:194
+msgid ""
+ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-orphan\">\n"
+ " <key column=\"parent_id\"/>\n"
+ " <one-to-many class=\"Child\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:196
+msgid "Note: even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. So if you require that an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr ""
+
+#: index.docbook:206
+msgid "Cascades and <literal>unsaved-value</literal>"
+msgstr ""
+
+#: index.docbook:208
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wish to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of childen and, since cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. Lets assume that both <literal>Parent</literal> and <literal>Child</literal> have genenerated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr ""
+
+#: index.docbook:220
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>."
+msgstr ""
+
+#: index.docbook:225
+msgid ""
+ "<![CDATA[//parent and child were both loaded in a previous session\n"
+ "parent.addChild(child);\n"
+ "Child newChild = new Child();\n"
+ "parent.addChild(newChild);\n"
+ "session.update(parent);\n"
+ "session.flush();]]>"
+msgstr ""
+
+#: index.docbook:227
+msgid "Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr ""
+
+#: index.docbook:260
+msgid "Conclusion"
+msgstr ""
+
+#: index.docbook:262
+msgid "There is quite a bit to digest here and it might look confusing first time around. However, in practice, it all works out very nicely. Most Hibernate applications use the parent / child pattern in many places."
+msgstr ""
+
+#: index.docbook:267
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal><composite-element></literal> mappings, which have exactly the semantics of a parent / child relationship. Unfortunately, there are two big limitations to composite element classes: composite elements may not own collections, and they should not be the child of any entity other than the unique parent."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/example_weblog.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/example_weblog.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/example_weblog.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,450 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Example: Weblog Application"
+msgstr ""
+
+#: index.docbook:8
+msgid "Persistent Classes"
+msgstr ""
+
+#: index.docbook:10
+msgid "The persistent classes represent a weblog, and an item posted in a weblog. They are to be modelled as a standard parent/child relationship, but we will use an ordered bag, instead of a set."
+msgstr ""
+
+#: index.docbook:16
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.List;\n"
+ "\n"
+ "public class Blog {\n"
+ " private Long _id;\n"
+ " private String _name;\n"
+ " private List _items;\n"
+ "\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public List getItems() {\n"
+ " return _items;\n"
+ " }\n"
+ " public String getName() {\n"
+ " return _name;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setItems(List list) {\n"
+ " _items = list;\n"
+ " }\n"
+ " public void setName(String string) {\n"
+ " _name = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:18
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.text.DateFormat;\n"
+ "import java.util.Calendar;\n"
+ "\n"
+ "public class BlogItem {\n"
+ " private Long _id;\n"
+ " private Calendar _datetime;\n"
+ " private String _text;\n"
+ " private String _title;\n"
+ " private Blog _blog;\n"
+ "\n"
+ " public Blog getBlog() {\n"
+ " return _blog;\n"
+ " }\n"
+ " public Calendar getDatetime() {\n"
+ " return _datetime;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return _id;\n"
+ " }\n"
+ " public String getText() {\n"
+ " return _text;\n"
+ " }\n"
+ " public String getTitle() {\n"
+ " return _title;\n"
+ " }\n"
+ " public void setBlog(Blog blog) {\n"
+ " _blog = blog;\n"
+ " }\n"
+ " public void setDatetime(Calendar calendar) {\n"
+ " _datetime = calendar;\n"
+ " }\n"
+ " public void setId(Long long1) {\n"
+ " _id = long1;\n"
+ " }\n"
+ " public void setText(String string) {\n"
+ " _text = string;\n"
+ " }\n"
+ " public void setTitle(String string) {\n"
+ " _title = string;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:23
+msgid "Hibernate Mappings"
+msgstr ""
+
+#: index.docbook:25
+msgid "The XML mappings should now be quite straightforward."
+msgstr ""
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"Blog\"\n"
+ " table=\"BLOGS\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " not-null=\"true\"\n"
+ " unique=\"true\"/>\n"
+ "\n"
+ " <bag\n"
+ " name=\"items\"\n"
+ " inverse=\"true\"\n"
+ " order-by=\"DATE_TIME\"\n"
+ " cascade=\"all\">\n"
+ "\n"
+ " <key column=\"BLOG_ID\"/>\n"
+ " <one-to-many class=\"BlogItem\"/>\n"
+ "\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:31
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping package=\"eg\">\n"
+ "\n"
+ " <class\n"
+ " name=\"BlogItem\"\n"
+ " table=\"BLOG_ITEMS\"\n"
+ " dynamic-update=\"true\">\n"
+ "\n"
+ " <id\n"
+ " name=\"id\"\n"
+ " column=\"BLOG_ITEM_ID\">\n"
+ "\n"
+ " <generator class=\"native\"/>\n"
+ "\n"
+ " </id>\n"
+ "\n"
+ " <property\n"
+ " name=\"title\"\n"
+ " column=\"TITLE\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"text\"\n"
+ " column=\"TEXT\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <property\n"
+ " name=\"datetime\"\n"
+ " column=\"DATE_TIME\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " <many-to-one\n"
+ " name=\"blog\"\n"
+ " column=\"BLOG_ID\"\n"
+ " not-null=\"true\"/>\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:36
+msgid "Hibernate Code"
+msgstr ""
+
+#: index.docbook:38
+msgid "The following class demonstrates some of the kinds of things we can do with these classes, using Hibernate."
+msgstr ""
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "import java.util.ArrayList;\n"
+ "import java.util.Calendar;\n"
+ "import java.util.Iterator;\n"
+ "import java.util.List;\n"
+ "\n"
+ "import org.hibernate.HibernateException;\n"
+ "import org.hibernate.Query;\n"
+ "import org.hibernate.Session;\n"
+ "import org.hibernate.SessionFactory;\n"
+ "import org.hibernate.Transaction;\n"
+ "import org.hibernate.cfg.Configuration;\n"
+ "import org.hibernate.tool.hbm2ddl.SchemaExport;\n"
+ "\n"
+ "public class BlogMain {\n"
+ " \n"
+ " private SessionFactory _sessions;\n"
+ " \n"
+ " public void configure() throws HibernateException {\n"
+ " _sessions = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class)\n"
+ " .buildSessionFactory();\n"
+ " }\n"
+ " \n"
+ " public void exportTables() throws HibernateException {\n"
+ " Configuration cfg = new Configuration()\n"
+ " .addClass(Blog.class)\n"
+ " .addClass(BlogItem.class);\n"
+ " new SchemaExport(cfg).create(true, true);\n"
+ " }\n"
+ " \n"
+ " public Blog createBlog(String name) throws HibernateException {\n"
+ " \n"
+ " Blog blog = new Blog();\n"
+ " blog.setName(name);\n"
+ " blog.setItems( new ArrayList() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.persist(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Blog blog, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setBlog(blog);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " blog.getItems().add(item);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(blog);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public BlogItem createBlogItem(Long blogid, String title, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " BlogItem item = new BlogItem();\n"
+ " item.setTitle(title);\n"
+ " item.setText(text);\n"
+ " item.setDatetime( Calendar.getInstance() );\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Blog blog = (Blog) session.load(Blog.class, blogid);\n"
+ " item.setBlog(blog);\n"
+ " blog.getItems().add(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return item;\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(BlogItem item, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " item.setText(text);\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " session.update(item);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public void updateBlogItem(Long itemid, String text)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " BlogItem item = (BlogItem) session.load(BlogItem.class, itemid);\n"
+ " item.setText(text);\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " }\n"
+ " \n"
+ " public List listAllBlogNamesAndItemCounts(int max)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"select blog.id, blog.name, count(blogItem) \" +\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join blog.items as blogItem \" +\n"
+ " \"group by blog.name, blog.id \" +\n"
+ " \"order by max(blogItem.datetime)\"\n"
+ " );\n"
+ " q.setMaxResults(max);\n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ " \n"
+ " public Blog getBlogAndAllItems(Long blogid)\n"
+ " throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " Blog blog = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"left outer join fetch blog.items \" +\n"
+ " \"where blog.id = :blogid\"\n"
+ " );\n"
+ " q.setParameter(\"blogid\", blogid);\n"
+ " blog = (Blog) q.uniqueResult();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return blog;\n"
+ " }\n"
+ " \n"
+ " public List listBlogsAndRecentItems() throws HibernateException {\n"
+ " \n"
+ " Session session = _sessions.openSession();\n"
+ " Transaction tx = null;\n"
+ " List result = null;\n"
+ " try {\n"
+ " tx = session.beginTransaction();\n"
+ " Query q = session.createQuery(\n"
+ " \"from Blog as blog \" +\n"
+ " \"inner join blog.items as blogItem \" +\n"
+ " \"where blogItem.datetime > :minDate\"\n"
+ " );\n"
+ "\n"
+ " Calendar cal = Calendar.getInstance();\n"
+ " cal.roll(Calendar.MONTH, false);\n"
+ " q.setCalendar(\"minDate\", cal);\n"
+ " \n"
+ " result = q.list();\n"
+ " tx.commit();\n"
+ " }\n"
+ " catch (HibernateException he) {\n"
+ " if (tx!=null) tx.rollback();\n"
+ " throw he;\n"
+ " }\n"
+ " finally {\n"
+ " session.close();\n"
+ " }\n"
+ " return result;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/filters.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/filters.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/filters.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,149 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Filtering data"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate3 provides an innovative new approach to handling data with \"visibility\" rules. A <emphasis>Hibernate filter</emphasis> is a global, named, parameterized filter that may be enabled or disabled for a particular Hibernate session."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate filters"
+msgstr ""
+
+#: index.docbook:16
+msgid "Hibernate3 adds the ability to pre-define filter criteria and attach those filters at both a class and a collection level. A filter criteria is the ability to define a restriction clause very similiar to the existing \"where\" attribute available on the class and various collection elements. Except these filter conditions can be parameterized. The application can then make the decision at runtime whether given filters should be enabled and what their parameter values should be. Filters can be used like database views, but parameterized inside the application."
+msgstr ""
+
+#: index.docbook:26
+msgid "In order to use filters, they must first be defined and then attached to the appropriate mapping elements. To define a filter, use the <literal><filter-def/></literal> element within a <literal><hibernate-mapping/></literal> element:"
+msgstr ""
+
+#: index.docbook:32
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\">\n"
+ " <filter-param name=\"myFilterParam\" type=\"string\"/>\n"
+ "</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:34
+msgid "Then, this filter can be attached to a class:"
+msgstr ""
+
+#: index.docbook:38
+msgid ""
+ "<![CDATA[<class name=\"myClass\" ...>\n"
+ " ...\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:40
+msgid "or, to a collection:"
+msgstr ""
+
+#: index.docbook:44
+msgid ""
+ "<![CDATA[<set ...>\n"
+ " <filter name=\"myFilter\" condition=\":myFilterParam = MY_FILTERED_COLUMN\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:46
+msgid "or, even to both (or multiples of each) at the same time."
+msgstr ""
+
+#: index.docbook:50
+msgid "The methods on <literal>Session</literal> are: <literal>enableFilter(String filterName)</literal>, <literal>getEnabledFilter(String filterName)</literal>, and <literal>disableFilter(String filterName)</literal>. By default, filters are <emphasis>not</emphasis> enabled for a given session; they must be explcitly enabled through use of the <literal>Session.enabledFilter()</literal> method, which returns an instance of the <literal>Filter</literal> interface. Using the simple filter defined above, this would look like:"
+msgstr ""
+
+#: index.docbook:59
+msgid "<![CDATA[session.enableFilter(\"myFilter\").setParameter(\"myFilterParam\", \"some-value\");]]>"
+msgstr ""
+
+#: index.docbook:61
+msgid "Note that methods on the org.hibernate.Filter interface do allow the method-chaining common to much of Hibernate."
+msgstr ""
+
+#: index.docbook:65
+msgid "A full example, using temporal data with an effective record date pattern:"
+msgstr ""
+
+#: index.docbook:69
+msgid ""
+ "<![CDATA[<filter-def name=\"effectiveDate\">\n"
+ " <filter-param name=\"asOfDate\" type=\"date\"/>\n"
+ "</filter-def>\n"
+ "\n"
+ "<class name=\"Employee\" ...>\n"
+ "...\n"
+ " <many-to-one name=\"department\" column=\"dept_id\" class=\"Department\"/>\n"
+ " <property name=\"effectiveStartDate\" type=\"date\" column=\"eff_start_dt\"/>\n"
+ " <property name=\"effectiveEndDate\" type=\"date\" column=\"eff_end_dt\"/>\n"
+ "...\n"
+ " <!--\n"
+ " Note that this assumes non-terminal records have an eff_end_dt set to\n"
+ " a max db date for simplicity-sake\n"
+ " -->\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"Department\" ...>\n"
+ "...\n"
+ " <set name=\"employees\" lazy=\"true\">\n"
+ " <key column=\"dept_id\"/>\n"
+ " <one-to-many class=\"Employee\"/>\n"
+ " <filter name=\"effectiveDate\"\n"
+ " condition=\":asOfDate BETWEEN eff_start_dt and eff_end_dt\"/>\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:71
+msgid "Then, in order to ensure that you always get back currently effective records, simply enable the filter on the session prior to retrieving employee data:"
+msgstr ""
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[Session session = ...;\n"
+ "session.enabledFilter(\"effectiveDate\").setParameter(\"asOfDate\", new Date());\n"
+ "List results = session.createQuery(\"from Employee as e where e.salary > :targetSalary\")\n"
+ " .setLong(\"targetSalary\", new Long(1000000))\n"
+ " .list();\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:78
+msgid "In the HQL above, even though we only explicitly mentioned a salary constraint on the results, because of the enabled filter the query will return only currently active employees who have a salary greater than a million dollars."
+msgstr ""
+
+#: index.docbook:84
+msgid "Note: if you plan on using filters with outer joining (either through HQL or load fetching) be careful of the direction of the condition expression. Its safest to set this up for left outer joining; in general, place the parameter first followed by the column name(s) after the operator."
+msgstr ""
+
+#: index.docbook:91
+msgid "After being defined a filter might be attached to multiple entities and/or collections each with its own condition. That can be tedious when the conditions are the same each time. Thus <literal><filter-def/></literal> allows defining a default condition, either as an attribute or CDATA:"
+msgstr ""
+
+#: index.docbook:98
+msgid ""
+ "<![CDATA[<filter-def name=\"myFilter\" condition=\"abc > xyz\">...</filter-def>\n"
+ "<filter-def name=\"myOtherFilter\">abc=xyz</filter-def>]]>"
+msgstr ""
+
+#: index.docbook:100
+msgid "This default condition will then be used whenever the filter is attached to something without specifying a condition. Note that this means you can give a specific condition as part of the attachment of the filter which overrides the default condition in that particular case."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/inheritance_mapping.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/inheritance_mapping.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/inheritance_mapping.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,477 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Inheritance Mapping"
+msgstr ""
+
+#: index.docbook:8
+msgid "The Three Strategies"
+msgstr ""
+
+#: index.docbook:10
+msgid "Hibernate supports the three basic inheritance mapping strategies:"
+msgstr ""
+
+#: index.docbook:16
+msgid "table per class hierarchy"
+msgstr ""
+
+#: index.docbook:21
+msgid "<para>table per subclass</para>"
+msgstr ""
+
+#: index.docbook:26
+msgid "table per concrete class"
+msgstr ""
+
+#: index.docbook:32
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
+msgstr ""
+
+#: index.docbook:39
+msgid "implicit polymorphism"
+msgstr ""
+
+#: index.docbook:45
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy, and then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, and <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below)."
+msgstr ""
+
+#: index.docbook:59
+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 hierachy just by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Note: Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files does not matter when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr ""
+
+#: index.docbook:70
+msgid ""
+ "<![CDATA[\n"
+ " <hibernate-mapping>\n"
+ " <subclass name=\"DomesticCat\" extends=\"Cat\" discriminator-value=\"D\">\n"
+ " <property name=\"name\" type=\"string\"/>\n"
+ " </subclass>\n"
+ " </hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:74
+msgid "Table per class hierarchy"
+msgstr ""
+
+#: index.docbook:76
+msgid "Suppose we have an interface <literal>Payment</literal>, with implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, <literal>ChequePayment</literal>. The table per hierarchy mapping would look like:"
+msgstr ""
+
+#: index.docbook:83
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:85
+msgid "Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, may not have <literal>NOT NULL</literal> constraints."
+msgstr ""
+
+#: index.docbook:94
+msgid "Table per subclass"
+msgstr ""
+
+#: index.docbook:96
+msgid "A table per subclass mapping would look like:"
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <joined-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:102
+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 ""
+
+#: index.docbook:111
+msgid "Table per subclass, using a discriminator"
+msgstr ""
+
+#: index.docbook:113
+msgid "Note that Hibernate's implementation of table per subclass requires no discriminator column. Other object/relational mappers use a different implementation of table per subclass which 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 would like to use a discriminator column with the table per subclass strategy, you may combine the use of <literal><subclass></literal> and <literal><join></literal>, as follow:"
+msgstr ""
+
+#: index.docbook:125
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " <join table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " <join table=\"CHEQUE_PAYMENT\" fetch=\"select\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:127
+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 ""
+
+#: index.docbook:136
+msgid "Mixing table per class hierarchy with table per subclass"
+msgstr ""
+
+#: index.docbook:138
+msgid "You may even mix the table per hierarchy and table per subclass strategies using this approach:"
+msgstr ""
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[<class name=\"Payment\" table=\"PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"PAYMENT_TYPE\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"CreditCardPayment\" discriminator-value=\"CREDIT\">\n"
+ " <join table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </join>\n"
+ " </subclass>\n"
+ " <subclass name=\"CashPayment\" discriminator-value=\"CASH\">\n"
+ " ...\n"
+ " </subclass>\n"
+ " <subclass name=\"ChequePayment\" discriminator-value=\"CHEQUE\">\n"
+ " ...\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:145
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr ""
+
+#: index.docbook:151
+msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "Table per concrete class"
+msgstr ""
+
+#: index.docbook:158
+msgid "There are two ways we could go about mapping the table per concrete class strategy. The first is to use <literal><union-subclass></literal>."
+msgstr ""
+
+#: index.docbook:163
+msgid ""
+ "<![CDATA[<class name=\"Payment\">\n"
+ " <id name=\"id\" type=\"long\" column=\"PAYMENT_ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"AMOUNT\"/>\n"
+ " ...\n"
+ " <union-subclass name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <property name=\"creditCardType\" column=\"CCTYPE\"/>\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ " <union-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " ...\n"
+ " </union-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:165
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr ""
+
+#: index.docbook:170
+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. (We might relax this in a future release of Hibernate.) The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has to be shared accross all unioned subclasses of a hierarchy."
+msgstr ""
+
+#: index.docbook:179
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. Of course, if it is not abstract, an additional table (defaults to <literal>PAYMENT</literal> in the example above) is needed to hold instances of the superclass."
+msgstr ""
+
+#: index.docbook:189
+msgid "Table per concrete class, using implicit polymorphism"
+msgstr ""
+
+#: index.docbook:191
+msgid "An alternative approach is to make use of implicit polymorphism:"
+msgstr ""
+
+#: index.docbook:195
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CASH_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CHEQUE_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:197
+msgid "Notice that nowhere do we mention the <literal>Payment</literal> interface 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 (e.g. <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&allproperties;</literal> in the mapping)."
+msgstr ""
+
+#: index.docbook:207
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr ""
+
+#: index.docbook:212
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr ""
+
+#: index.docbook:217
+msgid ""
+ "<![CDATA[<any name=\"payment\" meta-type=\"string\" id-type=\"long\">\n"
+ " <meta-value value=\"CREDIT\" class=\"CreditCardPayment\"/>\n"
+ " <meta-value value=\"CASH\" class=\"CashPayment\"/>\n"
+ " <meta-value value=\"CHEQUE\" class=\"ChequePayment\"/>\n"
+ " <column name=\"PAYMENT_CLASS\"/>\n"
+ " <column name=\"PAYMENT_ID\"/>\n"
+ "</any>]]>"
+msgstr ""
+
+#: index.docbook:222
+msgid "Mixing implicit polymorphism with other inheritance mappings"
+msgstr ""
+
+#: index.docbook:224
+msgid "There is one further thing to notice about this mapping. Since the subclasses are each mapped in their own <literal><class></literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)"
+msgstr ""
+
+#: index.docbook:232
+msgid ""
+ "<![CDATA[<class name=\"CreditCardPayment\" table=\"CREDIT_PAYMENT\">\n"
+ " <id name=\"id\" type=\"long\" column=\"CREDIT_PAYMENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <discriminator column=\"CREDIT_CARD\" type=\"string\"/>\n"
+ " <property name=\"amount\" column=\"CREDIT_AMOUNT\"/>\n"
+ " ...\n"
+ " <subclass name=\"MasterCardPayment\" discriminator-value=\"MDC\"/>\n"
+ " <subclass name=\"VisaPayment\" discriminator-value=\"VISA\"/>\n"
+ "</class>\n"
+ "\n"
+ "<class name=\"NonelectronicTransaction\" table=\"NONELECTRONIC_TXN\">\n"
+ " <id name=\"id\" type=\"long\" column=\"TXN_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " ...\n"
+ " <joined-subclass name=\"CashPayment\" table=\"CASH_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CASH_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ " <joined-subclass name=\"ChequePayment\" table=\"CHEQUE_PAYMENT\">\n"
+ " <key column=\"PAYMENT_ID\"/>\n"
+ " <property name=\"amount\" column=\"CHEQUE_AMOUNT\"/>\n"
+ " ...\n"
+ " </joined-subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:234
+msgid "Once again, we don't mention <literal>Payment</literal> 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 ""
+
+#: index.docbook:249
+msgid "Limitations"
+msgstr ""
+
+#: index.docbook:251
+msgid "There are certain limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr ""
+
+#: index.docbook:258
+msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr ""
+
+#: index.docbook:264
+msgid "Features of inheritance mappings"
+msgstr ""
+
+#: index.docbook:276
+msgid "Inheritance strategy"
+msgstr ""
+
+#: index.docbook:277
+msgid "Polymorphic many-to-one"
+msgstr ""
+
+#: index.docbook:278
+msgid "Polymorphic one-to-one"
+msgstr ""
+
+#: index.docbook:279
+msgid "Polymorphic one-to-many"
+msgstr ""
+
+#: index.docbook:280
+msgid "Polymorphic many-to-many"
+msgstr ""
+
+#: index.docbook:281
+msgid "Polymorphic <literal>load()/get()</literal>"
+msgstr ""
+
+#: index.docbook:282
+msgid "Polymorphic queries"
+msgstr ""
+
+#: index.docbook:283
+msgid "Polymorphic joins"
+msgstr ""
+
+#: index.docbook:284
+msgid "Outer join fetching"
+msgstr ""
+
+#: index.docbook:289
+msgid "table per class-hierarchy"
+msgstr ""
+
+#: index.docbook:290, index.docbook:301, index.docbook:312
+msgid "<many-to-one>"
+msgstr ""
+
+#: index.docbook:291, index.docbook:302, index.docbook:313
+msgid "<one-to-one>"
+msgstr ""
+
+#: index.docbook:292, index.docbook:303
+msgid "<one-to-many>"
+msgstr ""
+
+#: index.docbook:293, index.docbook:304, index.docbook:315
+msgid "<many-to-many>"
+msgstr ""
+
+#: index.docbook:294, index.docbook:305, index.docbook:316
+msgid "s.get(Payment.class, id)"
+msgstr ""
+
+#: index.docbook:295, index.docbook:306, index.docbook:317, index.docbook:328
+msgid "from Payment p"
+msgstr ""
+
+#: index.docbook:296, index.docbook:307, index.docbook:318
+msgid "from Order o join o.payment p"
+msgstr ""
+
+#: index.docbook:297, index.docbook:308, index.docbook:319
+msgid "supported"
+msgstr ""
+
+#: index.docbook:300
+msgid "<entry>table per subclass</entry>"
+msgstr ""
+
+#: index.docbook:311
+msgid "table per concrete-class (union-subclass)"
+msgstr ""
+
+#: index.docbook:314
+msgid "<literal><one-to-many></literal> (for <literal>inverse=\"true\"</literal> only)"
+msgstr ""
+
+#: index.docbook:322
+msgid "table per concrete class (implicit polymorphism)"
+msgstr ""
+
+#: index.docbook:323
+msgid "<any>"
+msgstr ""
+
+#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330
+msgid "not supported"
+msgstr ""
+
+#: index.docbook:326
+msgid "<many-to-any>"
+msgstr ""
+
+#: index.docbook:327
+msgid "s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/performance.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/performance.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/performance.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1068 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Improving performance"
+msgstr ""
+
+#: index.docbook:8
+msgid "Fetching strategies"
+msgstr ""
+
+#: index.docbook:10
+msgid "A <emphasis>fetching strategy</emphasis> is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. Fetch strategies may be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr ""
+
+#: index.docbook:17
+msgid "Hibernate3 defines the following fetching strategies:"
+msgstr ""
+
+#: index.docbook:23
+msgid "<emphasis>Join fetching</emphasis> - Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr ""
+
+#: index.docbook:30
+msgid "<emphasis>Select fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: index.docbook:39
+msgid "<emphasis>Subselect fetching</emphasis> - a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you actually access the association."
+msgstr ""
+
+#: index.docbook:48
+msgid "<emphasis>Batch fetching</emphasis> - an optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal>, by specifying a list of primary keys or foreign keys."
+msgstr ""
+
+#: index.docbook:57
+msgid "Hibernate also distinguishes between:"
+msgstr ""
+
+#: index.docbook:63
+msgid "<emphasis>Immediate fetching</emphasis> - an association, collection or attribute is fetched immediately, when the owner is loaded."
+msgstr ""
+
+#: index.docbook:69
+msgid "<emphasis>Lazy collection fetching</emphasis> - a collection is fetched when the application invokes an operation upon that collection. (This is the default for collections.)"
+msgstr ""
+
+#: index.docbook:76
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis> - individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed (suitable for very large collections)"
+msgstr ""
+
+#: index.docbook:84
+msgid "<emphasis>Proxy fetching</emphasis> - a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr ""
+
+#: index.docbook:91
+msgid "<emphasis>\"No-proxy\" fetching</emphasis> - a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy (the association is fetched even when only the identifier is accessed) but more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: index.docbook:101
+msgid "<emphasis>Lazy attribute fetching</emphasis> - an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr ""
+
+#: index.docbook:110
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched, and <emphasis>how</emphasis> is it fetched (what SQL is used). Don't confuse them! We use <literal>fetch</literal> to tune performance. We may use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr ""
+
+#: index.docbook:119
+msgid "Working with lazy associations"
+msgstr ""
+
+#: index.docbook:121
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for almost all associations in almost all applications."
+msgstr ""
+
+#: index.docbook:127
+msgid "<emphasis>Note:</emphasis> if you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching (this optimization may also be enabled at a more granular level)."
+msgstr ""
+
+#: index.docbook:134
+msgid "However, lazy fetching poses one problem that you must be aware of. Access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr ""
+
+#: index.docbook:140
+msgid ""
+ "<![CDATA[s = sessions.openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ " \n"
+ "User u = (User) s.createQuery(\"from User u where u.name=:userName\")\n"
+ " .setString(\"userName\", userName).uniqueResult();\n"
+ "Map permissions = u.getPermissions();\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();\n"
+ "\n"
+ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // Error!]]>"
+msgstr ""
+
+#: index.docbook:142
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. The fix is to move the code that reads from the collection to just before the transaction is committed."
+msgstr ""
+
+#: index.docbook:150
+msgid "Alternatively, we could use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will end up needing to fetch the entire database into memory in every transaction!"
+msgstr ""
+
+#: index.docbook:159
+msgid "On the other hand, we often want to choose join fetching (which is non-lazy by nature) instead of select fetching in a particular transaction. We'll now see how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr ""
+
+#: index.docbook:170
+msgid "Tuning fetch strategies"
+msgstr ""
+
+#: index.docbook:172
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr ""
+
+#: index.docbook:177
+msgid ""
+ "<![CDATA[<set name=\"permissions\" \n"
+ " fetch=\"join\">\n"
+ " <key column=\"userId\"/>\n"
+ " <one-to-many class=\"Permission\"/>\n"
+ "</set]]>"
+msgstr ""
+
+#: index.docbook:179
+msgid "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
+msgstr ""
+
+#: index.docbook:181
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr ""
+
+#: index.docbook:187
+msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
+msgstr ""
+
+#: index.docbook:192
+msgid "retrieval that happens implicitly when an association is navigated"
+msgstr ""
+
+#: index.docbook:197
+msgid "<literal>Criteria</literal> queries"
+msgstr ""
+
+#: index.docbook:202
+msgid "HQL queries if <literal>subselect</literal> fetching is used"
+msgstr ""
+
+#: index.docbook:208
+msgid "No matter what fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. Note that this might result in several immediate selects being used to execute a particular HQL query."
+msgstr ""
+
+#: index.docbook:214
+msgid "Usually, we don't use the mapping document to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr ""
+
+#: index.docbook:223
+msgid "If you ever feel like you wish you could change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, simply use a <literal>Criteria</literal> query, for example:"
+msgstr ""
+
+#: index.docbook:229
+msgid ""
+ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
+ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
+ " .add( Restrictions.idEq(userId) )\n"
+ " .uniqueResult();]]>"
+msgstr ""
+
+#: index.docbook:231
+msgid "(This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\".)"
+msgstr ""
+
+#: index.docbook:235
+msgid "A completely different way to avoid problems with N+1 selects is to use the second-level cache."
+msgstr ""
+
+#: index.docbook:243
+msgid "Single-ended association proxies"
+msgstr ""
+
+#: index.docbook:245
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement (via the excellent CGLIB library)."
+msgstr ""
+
+#: index.docbook:253
+msgid "By default, Hibernate3 generates proxies (at startup) for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr ""
+
+#: index.docbook:259
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>Note that the proxied class must implement a default constructor with at least package visibility. We recommend this constructor for all persistent classes!</emphasis>"
+msgstr ""
+
+#: index.docbook:266
+msgid "There are some gotchas to be aware of when extending this approach to polymorphic classes, eg."
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr ""
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a proxy (does not hit the db)\n"
+ "if ( cat.isDomesticCat() ) { // hit the db to initialize the proxy\n"
+ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:281
+msgid "Secondly, it is possible to break proxy <literal>==</literal>."
+msgstr ""
+
+#: index.docbook:285
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a Cat proxy\n"
+ "DomesticCat dc = \n"
+ " (DomesticCat) session.load(DomesticCat.class, id); // acquire new DomesticCat proxy!\n"
+ "System.out.println(cat==dc); // false]]>"
+msgstr ""
+
+#: index.docbook:287
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr ""
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
+ "System.out.println( dc.getWeight() ); // 11.0]]>"
+msgstr ""
+
+#: index.docbook:294
+msgid "Third, you may not use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr ""
+
+#: index.docbook:299
+msgid "Finally, if your persistent object acquires any resources upon instantiation (eg. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr ""
+
+#: index.docbook:305
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. If you wish to avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file. eg."
+msgstr ""
+
+#: index.docbook:311
+msgid ""
+ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
+ " ......\n"
+ " <subclass name=\"DomesticCatImpl\" proxy=\"DomesticCat\">\n"
+ " .....\n"
+ " </subclass>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:313
+msgid "where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> may be returned by <literal>load()</literal> or <literal>iterate()</literal>. (Note that <literal>list()</literal> does not usually return proxies.)"
+msgstr ""
+
+#: index.docbook:321
+msgid ""
+ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
+ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat.name='fritz'\").iterate();\n"
+ "Cat fritz = (Cat) iter.next();]]>"
+msgstr ""
+
+#: index.docbook:323
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr ""
+
+#: index.docbook:328
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization"
+msgstr ""
+
+#: index.docbook:334
+msgid "<literal>equals()</literal>, if the persistent class does not override <literal>equals()</literal>"
+msgstr ""
+
+#: index.docbook:340
+msgid "<literal>hashCode()</literal>, if the persistent class does not override <literal>hashCode()</literal>"
+msgstr ""
+
+#: index.docbook:346
+msgid "The identifier getter method"
+msgstr ""
+
+#: index.docbook:352
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr ""
+
+#: index.docbook:357
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, we can avoid the problems associated with typecasting. However, we will require buildtime bytecode instrumentation, and all operations will result in immediate proxy initialization."
+msgstr ""
+
+#: index.docbook:367
+msgid "Initializing collections and proxies"
+msgstr ""
+
+#: index.docbook:369
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, ie. when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr ""
+
+#: index.docbook:375
+msgid "Sometimes we need to ensure that a proxy or collection is initialized before closing the <literal>Session</literal>. Of course, we can alway force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. But that is confusing to readers of the code and is not convenient for generic code."
+msgstr ""
+
+#: index.docbook:382
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal> provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr ""
+
+#: index.docbook:391
+msgid "Another option is to keep the <literal>Session</literal> open until all needed collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr ""
+
+#: index.docbook:402
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the very end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr ""
+
+#: index.docbook:415
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that will be needed by the web tier before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr ""
+
+#: index.docbook:430
+msgid "You may also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections (or other proxies). No, Hibernate does not, and certainly <emphasis>should</emphasis> not do this automatically, since it would introduce ad hoc transaction semantics!"
+msgstr ""
+
+#: index.docbook:440
+msgid "Sometimes you don't want to initialize a large collection, but still need some information about it (like its size) or a subset of the data."
+msgstr ""
+
+#: index.docbook:445
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
+msgstr ""
+
+#: index.docbook:449
+msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>"
+msgstr ""
+
+#: index.docbook:451
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr ""
+
+#: index.docbook:456
+msgid "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0).setMaxResults(10).list();]]>"
+msgstr ""
+
+#: index.docbook:461
+msgid "Using batch fetching"
+msgstr ""
+
+#: index.docbook:463
+msgid "Hibernate can make efficient use of batch fetching, that is, Hibernate can load several uninitialized proxies if one proxy is accessed (or collections. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can tune batch fetching: on the class and the collection level."
+msgstr ""
+
+#: index.docbook:469
+msgid "Batch fetching for classes/entities is easier to understand. Imagine you have the following situation at runtime: You have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will by default execute 25 <literal>SELECT</literal> statements, to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr ""
+
+#: index.docbook:479
+msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
+msgstr ""
+
+#: index.docbook:481
+msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5."
+msgstr ""
+
+#: index.docbook:485
+msgid "You may also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Sesssion</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr ""
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <set name=\"cats\" batch-size=\"3\">\n"
+ " ...\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:496
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:502
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, ie. the typical bill-of-materials pattern. (Although a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees.)"
+msgstr ""
+
+#: index.docbook:511
+msgid "Using subselect fetching"
+msgstr ""
+
+#: index.docbook:513
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate loads all of them, re-running the original query in a subselect. This works in the same way as batch-fetching, without the piecemeal loading."
+msgstr ""
+
+#: index.docbook:524
+msgid "Using lazy property fetching"
+msgstr ""
+
+#: index.docbook:526
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature, as in practice, optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class might be useful in extreme cases, when legacy tables have hundreds of columns and the data model can not be improved."
+msgstr ""
+
+#: index.docbook:535
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr ""
+
+#: index.docbook:540
+msgid ""
+ "<![CDATA[<class name=\"Document\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\" length=\"50\"/>\n"
+ " <property name=\"summary\" not-null=\"true\" length=\"200\" lazy=\"true\"/>\n"
+ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:542
+msgid "Lazy property loading requires buildtime bytecode instrumentation! If your persistent classes are not enhanced, Hibernate will silently ignore lazy property settings and fall back to immediate fetching."
+msgstr ""
+
+#: index.docbook:548
+msgid "For bytecode instrumentation, use the following Ant task:"
+msgstr ""
+
+#: index.docbook:552
+msgid ""
+ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
+ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool.instrument.InstrumentTask\">\n"
+ " <classpath path=\"${jar.path}\"/>\n"
+ " <classpath path=\"${classes.dir}\"/>\n"
+ " <classpath refid=\"lib.class.path\"/>\n"
+ " </taskdef>\n"
+ "\n"
+ " <instrument verbose=\"true\">\n"
+ " <fileset dir=\"${testclasses.dir}/org/hibernate/auction/model\">\n"
+ " <include name=\"*.class\"/>\n"
+ " </fileset>\n"
+ " </instrument>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:554
+msgid "A different (better?) way to avoid unnecessary column reads, at least for read-only transactions is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a prefered solution."
+msgstr ""
+
+#: index.docbook:561
+msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr ""
+
+#: index.docbook:571
+msgid "The Second Level Cache"
+msgstr ""
+
+#: index.docbook:573
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You may even plug in a clustered cache. Be careful. Caches are never aware of changes made to the persistent store by another application (though they may be configured to regularly expire cached data)."
+msgstr ""
+
+#: index.docbook:581
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate comes bundled with a number of built-in integrations with open-source cache providers (listed below); additionally, you could implement your own and plug it in as outlined above. Note that versions prior to 3.2 defaulted to use EhCache as the default cache provider; that is no longer the case as of 3.2."
+msgstr ""
+
+#: index.docbook:592
+msgid "Cache Providers"
+msgstr ""
+
+#: index.docbook:601, index.docbook:774
+msgid "Cache"
+msgstr ""
+
+#: index.docbook:602
+msgid "Provider class"
+msgstr ""
+
+#: index.docbook:603
+msgid "Type"
+msgstr ""
+
+#: index.docbook:604
+msgid "Cluster Safe"
+msgstr ""
+
+#: index.docbook:605
+msgid "Query Cache Supported"
+msgstr ""
+
+#: index.docbook:610, index.docbook:783
+msgid "Hashtable (not intended for production use)"
+msgstr ""
+
+#: index.docbook:611
+msgid "org.hibernate.cache.HashtableCacheProvider"
+msgstr ""
+
+#: index.docbook:612
+msgid "memory"
+msgstr ""
+
+#: index.docbook:614, index.docbook:621, index.docbook:628, index.docbook:784, index.docbook:785, index.docbook:786, index.docbook:791, index.docbook:792, index.docbook:793, index.docbook:798, index.docbook:799, index.docbook:800, index.docbook:805, index.docbook:806, index.docbook:812, index.docbook:815
+msgid "<entry>yes</entry>"
+msgstr ""
+
+#: index.docbook:617, index.docbook:790
+msgid "EHCache"
+msgstr ""
+
+#: index.docbook:618
+msgid "org.hibernate.cache.EhCacheProvider"
+msgstr ""
+
+#: index.docbook:619, index.docbook:626
+msgid "memory, disk"
+msgstr ""
+
+#: index.docbook:624, index.docbook:797
+msgid "OSCache"
+msgstr ""
+
+#: index.docbook:625
+msgid "org.hibernate.cache.OSCacheProvider"
+msgstr ""
+
+#: index.docbook:631, index.docbook:804
+msgid "SwarmCache"
+msgstr ""
+
+#: index.docbook:632
+msgid "org.hibernate.cache.SwarmCacheProvider"
+msgstr ""
+
+#: index.docbook:633
+msgid "clustered (ip multicast)"
+msgstr ""
+
+#: index.docbook:634
+msgid "yes (clustered invalidation)"
+msgstr ""
+
+#: index.docbook:638, index.docbook:811
+msgid "JBoss TreeCache"
+msgstr ""
+
+#: index.docbook:639
+msgid "org.hibernate.cache.TreeCacheProvider"
+msgstr ""
+
+#: index.docbook:640
+msgid "clustered (ip multicast), transactional"
+msgstr ""
+
+#: index.docbook:641
+msgid "yes (replication)"
+msgstr ""
+
+#: index.docbook:642
+msgid "yes (clock sync req.)"
+msgstr ""
+
+#: index.docbook:649
+msgid "Cache mappings"
+msgstr ""
+
+#: index.docbook:651
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr ""
+
+#: index.docbook:662
+msgid ""
+ "<![CDATA[<cache \n"
+ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
+ " region=\"RegionName\"\n"
+ " include=\"all|non-lazy\"\n"
+ "/>]]>"
+msgstr ""
+
+#: index.docbook:665
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr ""
+
+#: index.docbook:674
+msgid "<literal>region</literal> (optional, defaults to the class or collection role name) specifies the name of the second level cache region"
+msgstr ""
+
+#: index.docbook:681
+msgid "<literal>include</literal> (optional, defaults to <literal>all</literal>) <literal>non-lazy</literal> specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> may not be cached when attribute-level lazy fetching is enabled"
+msgstr ""
+
+#: index.docbook:691
+msgid "Alternatively (preferrably?), you may specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr ""
+
+#: index.docbook:696
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr ""
+
+#: index.docbook:703
+msgid "Strategy: read only"
+msgstr ""
+
+#: index.docbook:705
+msgid "If your application needs to read but never modify instances of a persistent class, a <literal>read-only</literal> cache may be used. This is the simplest and best performing strategy. It's even perfectly safe for use in a cluster."
+msgstr ""
+
+#: index.docbook:711
+msgid ""
+ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
+ " <cache usage=\"read-only\"/>\n"
+ " ....\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:717
+msgid "Strategy: read/write"
+msgstr ""
+
+#: index.docbook:719
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal>, naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do <emphasis>not</emphasis>."
+msgstr ""
+
+#: index.docbook:730
+msgid ""
+ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " <set name=\"kittens\" ... >\n"
+ " <cache usage=\"read-write\"/>\n"
+ " ....\n"
+ " </set>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:735
+msgid "Strategy: nonstrict read/write"
+msgstr ""
+
+#: index.docbook:737
+msgid "If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr ""
+
+#: index.docbook:749
+msgid "Strategy: transactional"
+msgstr ""
+
+#: index.docbook:751
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr ""
+
+#: index.docbook:759
+msgid "None of the cache providers support all of the cache concurrency strategies. The following table shows which providers are compatible with which concurrency strategies."
+msgstr ""
+
+#: index.docbook:765
+msgid "Cache Concurrency Strategy Support"
+msgstr ""
+
+#: index.docbook:775
+msgid "read-only"
+msgstr ""
+
+#: index.docbook:776
+msgid "nonstrict-read-write"
+msgstr ""
+
+#: index.docbook:777
+msgid "read-write"
+msgstr ""
+
+#: index.docbook:778
+msgid "transactional"
+msgstr ""
+
+#: index.docbook:824
+msgid "Managing the caches"
+msgstr ""
+
+#: index.docbook:826
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal> and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:833
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method may be used to remove the object and its collections from the first-level cache."
+msgstr ""
+
+#: index.docbook:841
+msgid ""
+ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\").scroll(); //a huge result set\n"
+ "while ( cats.next() ) {\n"
+ " Cat cat = (Cat) cats.get(0);\n"
+ " doSomethingWithACat(cat);\n"
+ " sess.evict(cat);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:843
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr ""
+
+#: index.docbook:848
+msgid "To completely evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr ""
+
+#: index.docbook:852
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr ""
+
+#: index.docbook:858
+msgid ""
+ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular Cat\n"
+ "sessionFactory.evict(Cat.class); //evict all Cats\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\", catId); //evict a particular collection of kittens\n"
+ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten collections]]>"
+msgstr ""
+
+#: index.docbook:860
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache."
+msgstr ""
+
+#: index.docbook:867
+msgid "<literal>CacheMode.NORMAL</literal> - read items from and write items to the second-level cache"
+msgstr ""
+
+#: index.docbook:872
+msgid "<literal>CacheMode.GET</literal> - read items from the second-level cache, but don't write to the second-level cache except when updating data"
+msgstr ""
+
+#: index.docbook:878
+msgid "<literal>CacheMode.PUT</literal> - write items to the second-level cache, but don't read from the second-level cache"
+msgstr ""
+
+#: index.docbook:884
+msgid "<literal>CacheMode.REFRESH</literal> - write items to the second-level cache, but don't read from the second-level cache, bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal>, forcing a refresh of the second-level cache for all items read from the database"
+msgstr ""
+
+#: index.docbook:892
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr ""
+
+#: index.docbook:897
+msgid ""
+ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
+ " .getSecondLevelCacheStatistics(regionName)\n"
+ " .getEntries();]]>"
+msgstr ""
+
+#: index.docbook:899
+msgid "You'll need to enable statistics, and, optionally, force Hibernate to keep the cache entries in a more human-understandable format:"
+msgstr ""
+
+#: index.docbook:904
+msgid ""
+ "<![CDATA[hibernate.generate_statistics true\n"
+ "hibernate.cache.use_structured_entries true]]>"
+msgstr ""
+
+#: index.docbook:909
+msgid "The Query Cache"
+msgstr ""
+
+#: index.docbook:911
+msgid "Query result sets may also be cached. This is only useful for queries that are run frequently with the same parameters. To use the query cache you must first enable it:"
+msgstr ""
+
+#: index.docbook:916
+msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
+msgstr ""
+
+#: index.docbook:918
+msgid "This setting causes the creation of two new cache regions - one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. So the query cache should always be used in conjunction with the second-level cache."
+msgstr ""
+
+#: index.docbook:928
+msgid "Most queries do not benefit from caching, so by default queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr ""
+
+#: index.docbook:935
+msgid "If you require fine-grained control over query cache expiration policies, you may specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr ""
+
+#: index.docbook:941
+msgid ""
+ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog.blogger = :blogger\")\n"
+ " .setEntity(\"blogger\", blogger)\n"
+ " .setMaxResults(15)\n"
+ " .setCacheable(true)\n"
+ " .setCacheRegion(\"frontpages\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:943
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr ""
+
+#: index.docbook:955
+msgid "Understanding Collection performance"
+msgstr ""
+
+#: index.docbook:957
+msgid "We've already spent quite some time talking about collections. In this section we will highlight a couple more issues about how collections behave at runtime."
+msgstr ""
+
+#: index.docbook:964
+msgid "Taxonomy"
+msgstr ""
+
+#: index.docbook:966
+msgid "Hibernate defines three basic kinds of collections:"
+msgstr ""
+
+#: index.docbook:970
+msgid "collections of values"
+msgstr ""
+
+#: index.docbook:973
+msgid "one to many associations"
+msgstr ""
+
+#: index.docbook:976
+msgid "many to many associations"
+msgstr ""
+
+#: index.docbook:980
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr ""
+
+#: index.docbook:991
+msgid "indexed collections"
+msgstr ""
+
+#: index.docbook:994
+msgid "sets"
+msgstr ""
+
+#: index.docbook:997
+msgid "bags"
+msgstr ""
+
+#: index.docbook:1001
+msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case collection updates are usually extremely efficient - the primary key may be efficiently indexed and a particular row may be efficiently located when Hibernate tries to update or delete it."
+msgstr ""
+
+#: index.docbook:1009
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This may be less efficient for some types of collection element, particularly composite elements or large text or binary fields; the database may not be able to index a complex primary key as efficently. On the other hand, for one to many or many to many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. (Side-note: if you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)"
+msgstr ""
+
+#: index.docbook:1020
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case."
+msgstr ""
+
+#: index.docbook:1025
+msgid "Bags are the worst case. Since a bag permits duplicate element values and has no index column, no primary key may be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing (in a single <literal>DELETE</literal>) and recreating the collection whenever it changes. This might be very inefficient."
+msgstr ""
+
+#: index.docbook:1033
+msgid "Note that for a one-to-many association, the \"primary key\" may not be the physical primary key of the database table - but even in this case, the above classification is still useful. (It still reflects how Hibernate \"locates\" individual rows of the collection.)"
+msgstr ""
+
+#: index.docbook:1043
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
+msgstr ""
+
+#: index.docbook:1045
+msgid "From the discussion above, it should be clear that indexed collections and (usually) sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr ""
+
+#: index.docbook:1051
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many to many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate doesn't ever <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> (of individual rows). Once again, this consideration does not apply to one to many associations."
+msgstr ""
+
+#: index.docbook:1060
+msgid "After observing that arrays cannot be lazy, we would conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. Sets are expected to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr ""
+
+#: index.docbook:1068
+msgid "However, in well-designed Hibernate domain models, we usually see that most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr ""
+
+#: index.docbook:1078
+msgid "Bags and lists are the most efficient inverse collections"
+msgstr ""
+
+#: index.docbook:1080
+msgid "Just before you ditch bags forever, there is a particular case in which bags (and also lists) are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal> (the standard bidirectional one-to-many relationship idiom, for example) we can add elements to a bag or list without needing to initialize (fetch) the bag elements! This is because <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal> (unlike a <literal>Set</literal>). This can make the following common code much faster."
+msgstr ""
+
+#: index.docbook:1090
+msgid ""
+ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
+ "Child c = new Child();\n"
+ "c.setParent(p);\n"
+ "p.getChildren().add(c); //no need to fetch the collection!\n"
+ "sess.flush();]]>"
+msgstr ""
+
+#: index.docbook:1095
+msgid "One shot delete"
+msgstr ""
+
+#: index.docbook:1097
+msgid "Occasionally, deleting collection elements one by one can be extremely inefficient. Hibernate isn't completely stupid, so it knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal> and we are done!"
+msgstr ""
+
+#: index.docbook:1104
+msgid "Suppose we add a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements (unless the collection is a bag). This is certainly desirable."
+msgstr ""
+
+#: index.docbook:1110
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr ""
+
+#: index.docbook:1117
+msgid "delete eighteen rows one by one and then insert three rows"
+msgstr ""
+
+#: index.docbook:1120
+msgid "remove the whole collection (in one SQL <literal>DELETE</literal>) and insert all five current elements (one by one)"
+msgstr ""
+
+#: index.docbook:1125
+msgid "Hibernate isn't smart enough to know that the second option is probably quicker in this case. (And it would probably be undesirable for Hibernate to be that smart; such behaviour might confuse database triggers, etc.)"
+msgstr ""
+
+#: index.docbook:1131
+msgid "Fortunately, you can force this behaviour (ie. the second strategy) at any time by discarding (ie. dereferencing) the original collection and returning a newly instantiated collection with all the current elements. This can be very useful and powerful from time to time."
+msgstr ""
+
+#: index.docbook:1137
+msgid "Of course, one-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr ""
+
+#: index.docbook:1146
+msgid "Monitoring performance"
+msgstr ""
+
+#: index.docbook:1148
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1155
+msgid "Monitoring a SessionFactory"
+msgstr ""
+
+#: index.docbook:1157
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr ""
+
+#: index.docbook:1163
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You may enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr ""
+
+#: index.docbook:1170
+msgid ""
+ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"myFinancialApp\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "stats.setSessionFactory(sessionFactory); // Bind the stats to a SessionFactory\n"
+ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
+msgstr ""
+
+#: index.docbook:1173
+msgid ""
+ "<![CDATA[// MBean service registration for all SessionFactory's\n"
+ "Hashtable tb = new Hashtable();\n"
+ "tb.put(\"type\", \"statistics\");\n"
+ "tb.put(\"sessionFactory\", \"all\");\n"
+ "ObjectName on = new ObjectName(\"hibernate\", tb); // MBean object name\n"
+ "\n"
+ "StatisticsService stats = new StatisticsService(); // MBean implementation\n"
+ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
+msgstr ""
+
+#: index.docbook:1175
+msgid "TODO: This doesn't make sense: In the first case, we retrieve and use the MBean directly. In the second one, we must give the JNDI name in which the session factory is held before using it. Use <literal>hibernateStatsBean.setSessionFactoryJNDIName(\"my/JNDI/Name\")</literal>"
+msgstr ""
+
+#: index.docbook:1180
+msgid "You can (de)activate the monitoring for a <literal>SessionFactory</literal>"
+msgstr ""
+
+#: index.docbook:1185
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr ""
+
+#: index.docbook:1192
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr ""
+
+#: index.docbook:1199
+msgid "Statistics can be reset programatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr ""
+
+#: index.docbook:1208
+msgid "Metrics"
+msgstr ""
+
+#: index.docbook:1210
+msgid "Hibernate provides a number of metrics, from very basic to the specialized information only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr ""
+
+#: index.docbook:1217
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr ""
+
+#: index.docbook:1223
+msgid "Metrics related to he entities, collections, queries, and caches as a whole (aka global metrics),"
+msgstr ""
+
+#: index.docbook:1229
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
+msgstr ""
+
+#: index.docbook:1236
+msgid "For exampl,e you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Beware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision, on some platforms this might even only be accurate to 10 seconds."
+msgstr ""
+
+#: index.docbook:1243
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code shows a simple example:"
+msgstr ""
+
+#: index.docbook:1253
+msgid ""
+ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics();\n"
+ "\n"
+ "double queryCacheHitCount = stats.getQueryCacheHitCount();\n"
+ "double queryCacheMissCount = stats.getQueryCacheMissCount();\n"
+ "double queryCacheHitRatio =\n"
+ " queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount);\n"
+ "\n"
+ "log.info(\"Query Hit ratio:\" + queryCacheHitRatio);\n"
+ "\n"
+ "EntityStatistics entityStats =\n"
+ " stats.getEntityStatistics( Cat.class.getName() );\n"
+ "long changes =\n"
+ " entityStats.getInsertCount()\n"
+ " + entityStats.getUpdateCount()\n"
+ " + entityStats.getDeleteCount();\n"
+ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+msgstr ""
+
+#: index.docbook:1255
+msgid "To work on all entities, collections, queries and region caches, you can retrieve the list of names of entities, collections, queries and region caches with the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/persistent_classes.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/persistent_classes.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/persistent_classes.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,446 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Persistent Classes"
+msgstr ""
+
+#: index.docbook:7
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state - an instance may instead be transient or detached."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You may express a domain model in other ways: using trees of <literal>Map</literal> instances, for example."
+msgstr ""
+
+#: index.docbook:23
+msgid "A simple POJO example"
+msgstr ""
+
+#: index.docbook:25
+msgid "Most Java applications require a persistent class representing felines."
+msgstr ""
+
+#: index.docbook:29
+msgid ""
+ "<![CDATA[package eg;\n"
+ "import java.util.Set;\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Cat {\n"
+ " private Long id; // identifier\n"
+ "\n"
+ " private Date birthdate;\n"
+ " private Color color;\n"
+ " private char sex;\n"
+ " private float weight;\n"
+ " private int litterId;\n"
+ "\n"
+ " private Cat mother;\n"
+ " private Set kittens = new HashSet();\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id=id;\n"
+ " }\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " void setBirthdate(Date date) {\n"
+ " birthdate = date;\n"
+ " }\n"
+ " public Date getBirthdate() {\n"
+ " return birthdate;\n"
+ " }\n"
+ "\n"
+ " void setWeight(float weight) {\n"
+ " this.weight = weight;\n"
+ " }\n"
+ " public float getWeight() {\n"
+ " return weight;\n"
+ " }\n"
+ "\n"
+ " public Color getColor() {\n"
+ " return color;\n"
+ " }\n"
+ " void setColor(Color color) {\n"
+ " this.color = color;\n"
+ " }\n"
+ "\n"
+ " void setSex(char sex) {\n"
+ " this.sex=sex;\n"
+ " }\n"
+ " public char getSex() {\n"
+ " return sex;\n"
+ " }\n"
+ "\n"
+ " void setLitterId(int id) {\n"
+ " this.litterId = id;\n"
+ " }\n"
+ " public int getLitterId() {\n"
+ " return litterId;\n"
+ " }\n"
+ "\n"
+ " void setMother(Cat mother) {\n"
+ " this.mother = mother;\n"
+ " }\n"
+ " public Cat getMother() {\n"
+ " return mother;\n"
+ " }\n"
+ " void setKittens(Set kittens) {\n"
+ " this.kittens = kittens;\n"
+ " }\n"
+ " public Set getKittens() {\n"
+ " return kittens;\n"
+ " }\n"
+ " \n"
+ " // addKitten not needed by Hibernate\n"
+ " public void addKitten(Cat kitten) {\n"
+ " kitten.setMother(this);\n"
+ " kitten.setLitterId( kittens.size() ); \n"
+ " kittens.add(kitten);\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:31
+msgid "There are four main rules to follow here:"
+msgstr ""
+
+#: index.docbook:37
+msgid "Implement a no-argument constructor"
+msgstr ""
+
+#: index.docbook:39
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which may be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. We strongly recommend having a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr ""
+
+#: index.docbook:49
+msgid "Provide an identifier property (optional)"
+msgstr ""
+
+#: index.docbook:51
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. (If your legacy database table has composite keys, you can even use a user-defined class with properties of these types - see the section on composite identifiers later.)"
+msgstr ""
+
+#: index.docbook:60
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr ""
+
+#: index.docbook:65
+msgid "In fact, some functionality is available only to classes which declare an identifier property:"
+msgstr ""
+
+#: index.docbook:72
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see"
+msgstr ""
+
+#: index.docbook:79
+msgid "Session.saveOrUpdate()"
+msgstr ""
+
+#: index.docbook:84
+msgid "Session.merge()"
+msgstr ""
+
+#: index.docbook:89
+msgid "We recommend you declare consistently-named identifier properties on persistent classes. We further recommend that you use a nullable (ie. non-primitive) type."
+msgstr ""
+
+#: index.docbook:96
+msgid "Prefer non-final classes (optional)"
+msgstr ""
+
+#: index.docbook:97
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr ""
+
+#: index.docbook:102
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate, but you won't be able to use proxies for lazy association fetching - which will limit your options for performance tuning."
+msgstr ""
+
+#: index.docbook:107
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr ""
+
+#: index.docbook:115
+msgid "Declare accessors and mutators for persistent fields (optional)"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. We believe it is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties, and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. You may switch to direct field access for particular properties, if needed."
+msgstr ""
+
+#: index.docbook:127
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr ""
+
+#: index.docbook:138
+msgid "Implementing inheritance"
+msgstr ""
+
+#: index.docbook:140
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>."
+msgstr ""
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[package eg;\n"
+ "\n"
+ "public class DomesticCat extends Cat {\n"
+ " private String name;\n"
+ "\n"
+ " public String getName() {\n"
+ " return name;\n"
+ " }\n"
+ " protected void setName(String name) {\n"
+ " this.name=name;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:149
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr ""
+
+#: index.docbook:151
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you"
+msgstr ""
+
+#: index.docbook:157
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations) <emphasis>and</emphasis>"
+msgstr ""
+
+#: index.docbook:164
+msgid "intend to use reattachment of detached instances"
+msgstr ""
+
+#: index.docbook:170
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. So as soon as we mix instances retrieved in different sessions, we must implement <literal>equals()</literal> and <literal>hashCode()</literal> if we wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr ""
+
+#: index.docbook:178
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, they are therefore equal (if both are added to a <literal>Set</literal>, we will only have one element in the <literal>Set</literal>). Unfortunately, we can't use that approach with generated identifiers! Hibernate will only assign identifier values to objects that are persistent, a newly created instance will not have any identifier value! Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. Note that this is not a Hibernate issue, but !
normal Java semantics of object identity and equality."
+msgstr ""
+
+#: index.docbook:192
+msgid "We recommend implementing <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key, a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr ""
+
+#: index.docbook:200
+msgid ""
+ "<![CDATA[public class Cat {\n"
+ "\n"
+ " ...\n"
+ " public boolean equals(Object other) {\n"
+ " if (this == other) return true;\n"
+ " if ( !(other instanceof Cat) ) return false;\n"
+ "\n"
+ " final Cat cat = (Cat) other;\n"
+ "\n"
+ " if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
+ " if ( !cat.getMother().equals( getMother() ) ) return false;\n"
+ "\n"
+ " return true;\n"
+ " }\n"
+ "\n"
+ " public int hashCode() {\n"
+ " int result;\n"
+ " result = getMother().hashCode();\n"
+ " result = 29 * result + getLitterId();\n"
+ " return result;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:202
+msgid "Note that a business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
+msgstr ""
+
+#: index.docbook:212
+msgid "Dynamic models"
+msgstr ""
+
+#: index.docbook:215
+msgid "Note that the following features are currently considered experimental and may change in the near future."
+msgstr ""
+
+#: index.docbook:219
+msgid "Persistent entities don't necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you don't write persistent classes, only mapping files."
+msgstr ""
+
+#: index.docbook:227
+msgid "By default, Hibernate works in normal POJO mode. You may set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\"/>."
+msgstr ""
+
+#: index.docbook:234
+msgid "The following examples demonstrates the representation using <literal>Map</literal>s. First, in the mapping file, an <literal>entity-name</literal> has to be declared instead of (or in addition to) a class name:"
+msgstr ""
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class entity-name=\"Customer\">\n"
+ "\n"
+ " <id name=\"id\"\n"
+ " type=\"long\"\n"
+ " column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <property name=\"name\"\n"
+ " column=\"NAME\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <property name=\"address\"\n"
+ " column=\"ADDRESS\"\n"
+ " type=\"string\"/>\n"
+ "\n"
+ " <many-to-one name=\"organization\"\n"
+ " column=\"ORGANIZATION_ID\"\n"
+ " class=\"Organization\"/>\n"
+ "\n"
+ " <bag name=\"orders\"\n"
+ " inverse=\"true\"\n"
+ " lazy=\"false\"\n"
+ " cascade=\"all\">\n"
+ " <key column=\"CUSTOMER_ID\"/>\n"
+ " <one-to-many class=\"Order\"/>\n"
+ " </bag>\n"
+ "\n"
+ " </class>\n"
+ " \n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:242
+msgid "Note that even though associations are declared using target class names, the target type of an associations may also be a dynamic entity instead of a POJO."
+msgstr ""
+
+#: index.docbook:249
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, we can at runtime work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr ""
+
+#: index.docbook:255
+msgid ""
+ "<![CDATA[Session s = openSession();\n"
+ "Transaction tx = s.beginTransaction();\n"
+ "Session s = openSession();\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "\n"
+ "// Create an organization\n"
+ "Map foobar = new HashMap();\n"
+ "foobar.put(\"name\", \"Foobar Inc.\");\n"
+ "\n"
+ "// Link both\n"
+ "david.put(\"organization\", foobar);\n"
+ "\n"
+ "// Save both\n"
+ "s.save(\"Customer\", david);\n"
+ "s.save(\"Organization\", foobar);\n"
+ "\n"
+ "tx.commit();\n"
+ "s.close();]]>"
+msgstr ""
+
+#: index.docbook:257
+msgid "The advantages of a dynamic mapping are quick turnaround time for prototyping without the need for entity class implementation. However, you lose compile-time type checking and will very likely deal with many exceptions at runtime. Thanks to the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr ""
+
+#: index.docbook:265
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
+msgstr ""
+
+#: index.docbook:270
+msgid ""
+ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
+ "\n"
+ "// Create a customer\n"
+ "Map david = new HashMap();\n"
+ "david.put(\"name\", \"David\");\n"
+ "dynamicSession.save(\"Customer\", david);\n"
+ "...\n"
+ "dynamicSession.flush();\n"
+ "dynamicSession.close()\n"
+ "...\n"
+ "// Continue on pojoSession\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you don't have tocall <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr ""
+
+#: index.docbook:283
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
+msgstr ""
+
+#: index.docbook:291
+msgid "Tuplizers"
+msgstr ""
+
+#: index.docbook:293
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data, given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing which knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the correpsonding tuplizer knows how create the POJO through its constructor and how to access the POJO properties using the defined property accessors. There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTu!
plizer</literal>s do the same for components."
+msgstr ""
+
+#: index.docbook:308
+msgid "Users may also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode; or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizers definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr ""
+
+#: index.docbook:317
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ " <class entity-name=\"Customer\">\n"
+ " <!--\n"
+ " Override the dynamic-map entity-mode\n"
+ " tuplizer for the customer entity\n"
+ " -->\n"
+ " <tuplizer entity-mode=\"dynamic-map\"\n"
+ " class=\"CustomMapTuplizerImpl\"/>\n"
+ "\n"
+ " <id name=\"id\" type=\"long\" column=\"ID\">\n"
+ " <generator class=\"sequence\"/>\n"
+ " </id>\n"
+ "\n"
+ " <!-- other properties -->\n"
+ " ...\n"
+ " </class>\n"
+ "</hibernate-mapping>\n"
+ "\n"
+ "\n"
+ "public class CustomMapTuplizerImpl\n"
+ " extends org.hibernate.tuple.entity.DynamicMapEntityTuplizer {\n"
+ " // override the buildInstantiator() method to plug in our custom map...\n"
+ " protected final Instantiator buildInstantiator(\n"
+ " org.hibernate.mapping.PersistentClass mappingInfo) {\n"
+ " return new CustomMapInstantiator( mappingInfo );\n"
+ " }\n"
+ "\n"
+ " private static final class CustomMapInstantiator\n"
+ " extends org.hibernate.tuple.DynamicMapInstantitor {\n"
+ " // override the generateMap() method to return our custom map...\n"
+ " protected final Map generateMap() {\n"
+ " return new CustomMap();\n"
+ " }\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:322
+msgid "TODO: Document user-extension framework in the property and proxy packages"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/preface.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/preface.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/preface.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,68 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:21
+msgid "Preface"
+msgstr "<title>å‰è¨€</title>"
+
+#: index.docbook:23
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "在今日的ä¼ä¸šçŽ¯å¢ƒä¸ï¼ŒæŠŠé¢å‘对象的软件和关系数æ®åº“一起使用å¯èƒ½æ˜¯ç›¸å½“麻烦ã€æµªè´¹æ—¶é—´çš„。Hibernate是一个é¢å‘Java环境的对象/关系数æ®åº“æ˜ å°„å·¥å…·ã€‚å¯¹è±¡/关系数æ®åº“æ˜ å°„(object/relational mapping (ORM))这个术è¯è¡¨ç¤ºä¸€ç§æŠ€æœ¯ï¼Œç”¨æ¥æŠŠå¯¹è±¡æ¨¡åž‹è¡¨ç¤ºçš„å¯¹è±¡æ˜ å°„åˆ°åŸºäºŽSQL的关系模型数æ®ç»“æž„ä¸åŽ»ã€‚"
+
+#: index.docbook:31
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Hibernateä¸ä»…仅管ç†Java类到数æ®åº“è¡¨çš„æ˜ å°„ï¼ˆåŒ…æ‹¬Javaæ•°æ®ç±»åž‹åˆ°SQLæ•°æ®ç±»åž‹çš„æ˜ å°„ï¼‰ï¼Œè¿˜æ供数æ®æŸ¥è¯¢å’ŒèŽ·å–æ•°æ®çš„方法，å¯ä»¥å¤§å¹…度å‡å°‘å¼€å‘时人工使用SQLå’ŒJDBC处ç†æ•°æ®çš„时间。"
+
+#: index.docbook:38
+msgid "Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "Hibernateçš„ç›®æ ‡æ˜¯å¯¹äºŽå¼€å‘者通常的数æ®æŒä¹…化相关的编程任务，解放其ä¸çš„95%。对于以数æ®ä¸ºä¸å¿ƒçš„程åºæ¥è¯´,它们往往åªåœ¨æ•°æ®åº“ä¸ä½¿ç”¨å˜å‚¨è¿‡ç¨‹æ¥å®žçŽ°å•†ä¸šé€»è¾‘,Hibernateå¯èƒ½ä¸æ˜¯æœ€å¥½çš„解决方案;对于那些在基于Javaçš„ä¸é—´å±‚应用ä¸ï¼Œå®ƒä»¬å®žçŽ°é¢å‘对象的业务模型和商业逻辑的应用，Hibernate是最有用的。ä¸ç®¡æ€Žæ ·ï¼ŒHibernate一定å¯ä»¥å¸®åŠ©ä½ 消除或者包装那些针对特定厂商的SQL代ç ï¼Œå¹¶ä¸”å¸®ä½ æŠŠç»“æžœé›†ä»Žè¡¨æ ¼å¼çš„表示形å¼è½¬æ¢åˆ°ä¸€ç³»åˆ—的对象去。"
+
+#: index.docbook:48
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "å¦‚æžœä½ å¯¹Hibernate和对象/关系数æ®åº“æ˜ å°„è¿˜æ˜¯ä¸ªæ–°æ‰‹ï¼Œæˆ–è€…ç”šè‡³å¯¹Java也ä¸ç†Ÿæ‚‰ï¼Œè¯·æŒ‰ç…§ä¸‹é¢çš„æ¥éª¤æ¥å¦ä¹ 。"
+
+#: index.docbook:55
+msgid "Read <xref linkend=\"tutorial\"/> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "阅读<xref linkend=\"tutorial\"/>，这是一篇包å«è¯¦ç»†çš„é€æ¥æŒ‡å¯¼çš„指å—。本指å—çš„æºä»£ç 包å«åœ¨å‘行包ä¸ï¼Œä½ å¯ä»¥åœ¨<literal>doc/reference/tutorial/</literal>目录下找到。"
+
+#: index.docbook:63
+msgid "Read <xref linkend=\"architecture\"/> to understand the environments where Hibernate can be used."
+msgstr "阅读<xref linkend=\"architecture\"/>æ¥ç†è§£Hibernateå¯ä»¥ä½¿ç”¨çš„环境。"
+
+#: index.docbook:69
+msgid "Have a look at the <literal>eg/</literal> directory in the Hibernate distribution, it contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "查看Hibernateå‘行包ä¸çš„<literal>eg/</literal>目录，里é¢æœ‰ä¸€ä¸ªç®€å•çš„独立è¿è¡Œçš„程åºã€‚æŠŠä½ çš„JDBC驱动拷è´åˆ°<literal>lib/</literal>目录下，修改一下<literal>src/hibernate.properties</literal>,指定其ä¸ä½ çš„æ•°æ®åº“çš„ä¿¡æ¯ã€‚进入命令行，切æ¢åˆ°ä½ çš„å‘行包的目录，输入<literal>ant eg</literal>(使用了Ant），或者在Windowsæ“作系统ä¸ä½¿ç”¨<literal>build eg</literal>。"
+
+#: index.docbook:80
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "把这份å‚è€ƒæ–‡æ¡£ä½œä¸ºä½ å¦ä¹ 的主è¦ä¿¡æ¯æ¥æºã€‚"
+
+#: index.docbook:90
+msgid "FAQs are answered on the Hibernate website."
+msgstr "在Hibernate 的网站上å¯ä»¥æ‰¾åˆ°ç»å¸¸æ问的问题与解ç”(FAQ)。"
+
+#: index.docbook:95
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
+msgstr "在Hibernate网站上还有第三方的演示ã€ç¤ºä¾‹å’Œæ•™ç¨‹çš„链接。"
+
+#: index.docbook:101
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "Hibernate网站的“社区(Community Area)â€æ˜¯è®¨è®ºå…³äºŽè®¾è®¡æ¨¡å¼ä»¥åŠå¾ˆå¤šæ•´åˆæ–¹æ¡ˆ(Tomcat, JBoss AS, Struts, EJB,ç‰ç‰)的好地方。"
+
+#: index.docbook:109
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue trackings system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "å¦‚æžœä½ æœ‰é—®é¢˜ï¼Œè¯·ä½¿ç”¨Hibernate网站上链接的用户论å›ã€‚我们也æ供一个JIRA问题追踪系统，æ¥æœé›†bugæŠ¥å‘Šå’Œæ–°åŠŸèƒ½è¯·æ±‚ã€‚å¦‚æžœä½ å¯¹å¼€å‘Hibernateæœ‰å…´è¶£ï¼Œè¯·åŠ å…¥å¼€å‘者的邮件列表。（Hibernate网站上的用户论å›æœ‰ä¸€ä¸ªä¸æ–‡ç‰ˆé¢ï¼ŒJavaEye也有Hibernateä¸æ–‡ç‰ˆé¢,您å¯ä»¥åœ¨é‚£é‡Œäº¤æµé—®é¢˜ä¸Žç»éªŒã€‚）"
+
+#: index.docbook:117
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "商业开å‘ã€äº§å“支æŒå’ŒHibernate培è®å¯ä»¥é€šè¿‡JBoss Inc.获得。（请查阅：http://www.hibernate.org/SupportTraining/）。 Hibernate是一个专业的开放æºä»£ç 项目(Professional Open Source project)，也是JBoss Enterprise Middleware System(JEMS),JBossä¼ä¸šçº§ä¸é—´ä»¶ç³»ç»Ÿçš„ä¸€ä¸ªæ ¸å¿ƒç»„ä»¶ã€‚"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/query_criteria.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/query_criteria.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/query_criteria.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,484 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Criteria Queries"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate features an intuitive, extensible criteria query API."
+msgstr ""
+
+#: index.docbook:12
+msgid "Creating a <literal>Criteria</literal> instance"
+msgstr ""
+
+#: index.docbook:14
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr ""
+
+#: index.docbook:20
+msgid ""
+ "<![CDATA[Criteria crit = sess.createCriteria(Cat.class);\n"
+ "crit.setMaxResults(50);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+
+#: index.docbook:25
+msgid "Narrowing the result set"
+msgstr ""
+
+#: index.docbook:27
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr ""
+
+#: index.docbook:35
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.between(\"weight\", minWeight, maxWeight) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:37
+msgid "Restrictions may be grouped logically."
+msgstr ""
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .add( Restrictions.or(\n"
+ " Restrictions.eq( \"age\", new Integer(0) ),\n"
+ " Restrictions.isNull(\"age\")\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:43
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.in( \"name\", new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( Restrictions.isNull(\"age\") )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(0) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(1) ) )\n"
+ " .add( Restrictions.eq(\"age\", new Integer(2) ) )\n"
+ " ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:45
+msgid "There are quite a range of built-in criterion types (<literal>Restrictions</literal> subclasses), but one that is especially useful lets you specify SQL directly."
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.sqlRestriction(\"lower({alias}.name) like lower(?)\", \"Fritz%\", Hibernate.STRING) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:52
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
+msgstr ""
+
+#: index.docbook:57
+msgid "An alternative approach to obtaining a criterion is to get it from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>."
+msgstr ""
+
+#: index.docbook:63
+msgid ""
+ "<![CDATA[\n"
+ "Property age = Property.forName(\"age\");\n"
+ "List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.disjunction()\n"
+ " .add( age.isNull() )\n"
+ " .add( age.eq( new Integer(0) ) )\n"
+ " .add( age.eq( new Integer(1) ) )\n"
+ " .add( age.eq( new Integer(2) ) )\n"
+ " ) )\n"
+ " .add( Property.forName(\"name\").in( new String[] { \"Fritz\", \"Izi\", \"Pk\" } ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:68
+msgid "Ordering the results"
+msgstr ""
+
+#: index.docbook:70
+msgid "You may order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr ""
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\")\n"
+ " .addOrder( Order.asc(\"name\") )\n"
+ " .addOrder( Order.desc(\"age\") )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:76
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"name\").like(\"F%\") )\n"
+ " .addOrder( Property.forName(\"name\").asc() )\n"
+ " .addOrder( Property.forName(\"age\").desc() )\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:81
+msgid "Associations"
+msgstr ""
+
+#: index.docbook:83
+msgid "You may easily specify constraints upon related entities by navigating associations using <literal>createCriteria()</literal>."
+msgstr ""
+
+#: index.docbook:88
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .createCriteria(\"kittens\")\n"
+ " .add( Restrictions.like(\"name\", \"F%\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:90
+msgid "note that the second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal>, which refers to the elements of the <literal>kittens</literal> collection."
+msgstr ""
+
+#: index.docbook:96
+msgid "The following, alternate form is useful in certain circumstances."
+msgstr ""
+
+#: index.docbook:100
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createAlias(\"kittens\", \"kt\")\n"
+ " .createAlias(\"mate\", \"mt\")\n"
+ " .add( Restrictions.eqProperty(\"kt.name\", \"mt.name\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:102
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr ""
+
+#: index.docbook:107
+msgid "Note that the kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria! If you wish to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr ""
+
+#: index.docbook:114
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .createCriteria(\"kittens\", \"kt\")\n"
+ " .add( Restrictions.eq(\"name\", \"F%\") )\n"
+ " .setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP)\n"
+ " .list();\n"
+ "Iterator iter = cats.iterator();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Map map = (Map) iter.next();\n"
+ " Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);\n"
+ " Cat kitten = (Cat) map.get(\"kt\");\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:119
+msgid "Dynamic association fetching"
+msgstr ""
+
+#: index.docbook:121
+msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[List cats = sess.createCriteria(Cat.class)\n"
+ " .add( Restrictions.like(\"name\", \"Fritz%\") )\n"
+ " .setFetchMode(\"mate\", FetchMode.EAGER)\n"
+ " .setFetchMode(\"kittens\", FetchMode.EAGER)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:136
+msgid "Example queries"
+msgstr ""
+
+#: index.docbook:138
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr ""
+
+#: index.docbook:143
+msgid ""
+ "<![CDATA[Cat cat = new Cat();\n"
+ "cat.setSex('F');\n"
+ "cat.setColor(Color.BLACK);\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:145
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
+msgstr ""
+
+#: index.docbook:150
+msgid "You can adjust how the <literal>Example</literal> is applied."
+msgstr ""
+
+#: index.docbook:154
+msgid ""
+ "<![CDATA[Example example = Example.create(cat)\n"
+ " .excludeZeroes() //exclude zero valued properties\n"
+ " .excludeProperty(\"color\") //exclude the property named \"color\"\n"
+ " .ignoreCase() //perform case insensitive string comparisons\n"
+ " .enableLike(); //use like for string comparisons\n"
+ "List results = session.createCriteria(Cat.class)\n"
+ " .add(example)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:156
+msgid "You can even use examples to place criteria upon associated objects."
+msgstr ""
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .add( Example.create(cat) )\n"
+ " .createCriteria(\"mate\")\n"
+ " .add( Example.create( cat.getMate() ) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:165
+msgid "Projections, aggregation and grouping"
+msgstr ""
+
+#: index.docbook:166
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. We apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr ""
+
+#: index.docbook:172
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.rowCount() )\n"
+ " .add( Restrictions.eq(\"color\", Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount() )\n"
+ " .add( Projections.avg(\"weight\") )\n"
+ " .add( Projections.max(\"weight\") )\n"
+ " .add( Projections.groupProperty(\"color\") )\n"
+ " )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:176
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr ""
+
+#: index.docbook:182
+msgid "An alias may optionally be assigned to a projection, so that the projected value may be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr ""
+
+#: index.docbook:188
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.alias( Projections.groupProperty(\"color\"), \"colr\" ) )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:190
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.groupProperty(\"color\").as(\"colr\") )\n"
+ " .addOrder( Order.asc(\"colr\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:192
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr ""
+
+#: index.docbook:199
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount(), \"catCountByColor\" )\n"
+ " .add( Projections.avg(\"weight\"), \"avgWeight\" )\n"
+ " .add( Projections.max(\"weight\"), \"maxWeight\" )\n"
+ " .add( Projections.groupProperty(\"color\"), \"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:201
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Domestic.class, \"cat\")\n"
+ " .createAlias(\"kittens\", \"kit\")\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.property(\"cat.name\"), \"catName\" )\n"
+ " .add( Projections.property(\"kit.name\"), \"kitName\" )\n"
+ " )\n"
+ " .addOrder( Order.asc(\"catName\") )\n"
+ " .addOrder( Order.asc(\"kitName\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:203
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
+msgstr ""
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Property.forName(\"name\") )\n"
+ " .add( Property.forName(\"color\").eq(Color.BLACK) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:209
+msgid ""
+ "<![CDATA[List results = session.createCriteria(Cat.class)\n"
+ " .setProjection( Projections.projectionList()\n"
+ " .add( Projections.rowCount().as(\"catCountByColor\") )\n"
+ " .add( Property.forName(\"weight\").avg().as(\"avgWeight\") )\n"
+ " .add( Property.forName(\"weight\").max().as(\"maxWeight\") )\n"
+ " .add( Property.forName(\"color\").group().as(\"color\" )\n"
+ " )\n"
+ " .addOrder( Order.desc(\"catCountByColor\") )\n"
+ " .addOrder( Order.desc(\"avgWeight\") )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:214
+msgid "Detached queries and subqueries"
+msgstr ""
+
+#: index.docbook:215
+msgid "The <literal>DetachedCriteria</literal> class lets you create a query outside the scope of a session, and then later execute it using some arbitrary <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:220
+msgid ""
+ "<![CDATA[DetachedCriteria query = DetachedCriteria.forClass(Cat.class)\n"
+ " .add( Property.forName(\"sex\").eq('F') );\n"
+ " \n"
+ "Session session = ....;\n"
+ "Transaction txn = session.beginTransaction();\n"
+ "List results = query.getExecutableCriteria(session).setMaxResults(100).list();\n"
+ "txn.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:222
+msgid "A <literal>DetachedCriteria</literal> may also be used to express a subquery. Criterion instances involving subqueries may be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr ""
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\").avg() );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Property.forName(\"weight\").gt(avgWeight) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:230
+msgid ""
+ "<![CDATA[DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)\n"
+ " .setProjection( Property.forName(\"weight\") );\n"
+ "session.createCriteria(Cat.class)\n"
+ " .add( Subqueries.geAll(\"weight\", weights) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:232
+msgid "Even correlated subqueries are possible:"
+msgstr ""
+
+#: index.docbook:236
+msgid ""
+ "<![CDATA[DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, \"cat2\")\n"
+ " .setProjection( Property.forName(\"weight\").avg() )\n"
+ " .add( Property.forName(\"cat2.sex\").eqProperty(\"cat.sex\") );\n"
+ "session.createCriteria(Cat.class, \"cat\")\n"
+ " .add( Property.forName(\"weight\").gt(avgWeightForSex) )\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:245
+msgid "Queries by natural identifier"
+msgstr ""
+
+#: index.docbook:247
+msgid "For most queries, including criteria queries, the query cache is not very efficient, because query cache invalidation occurs too frequently. However, there is one special kind of query where we can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr ""
+
+#: index.docbook:255
+msgid "First, you should map the natural key of your entity using <literal><natural-id></literal>, and enable use of the second-level cache."
+msgstr ""
+
+#: index.docbook:260
+msgid ""
+ "<![CDATA[<class name=\"User\">\n"
+ " <cache usage=\"read-write\"/>\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <natural-id>\n"
+ " <property name=\"name\"/>\n"
+ " <property name=\"org\"/>\n"
+ " </natural-id>\n"
+ " <property name=\"password\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:262
+msgid "Note that this functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr ""
+
+#: index.docbook:267
+msgid "Next, enable the Hibernate query cache."
+msgstr ""
+
+#: index.docbook:271
+msgid "Now, <literal>Restrictions.naturalId()</literal> allows us to make use of the more efficient cache algorithm."
+msgstr ""
+
+#: index.docbook:276
+msgid ""
+ "<![CDATA[session.createCriteria(User.class)\n"
+ " .add( Restrictions.naturalId()\n"
+ " .set(\"name\", \"gavin\")\n"
+ " .set(\"org\", \"hb\") \n"
+ " ).setCacheable(true)\n"
+ " .uniqueResult();]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/query_hql.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/query_hql.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/query_hql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1275 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "HQL: The Hibernate Query Language"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate is equipped with an extremely powerful query language that (quite intentionally) looks very much like SQL. But don't be fooled by the syntax; HQL is fully object-oriented, understanding notions like inheritence, polymorphism and association."
+msgstr ""
+
+#: index.docbook:14
+msgid "Case Sensitivity"
+msgstr ""
+
+#: index.docbook:16
+msgid "Queries are case-insensitive, except for names of Java classes and properties. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal> but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal> and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr ""
+
+#: index.docbook:27
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but we find this convention ugly when embedded in Java code."
+msgstr ""
+
+#: index.docbook:35
+msgid "The from clause"
+msgstr ""
+
+#: index.docbook:37
+msgid "The simplest possible Hibernate query is of the form:"
+msgstr ""
+
+#: index.docbook:41
+msgid "<![CDATA[from eg.Cat]]>"
+msgstr ""
+
+#: index.docbook:43
+msgid "which simply returns all instances of the class <literal>eg.Cat</literal>. We don't usually need to qualify the class name, since <literal>auto-import</literal> is the default. So we almost always just write:"
+msgstr ""
+
+#: index.docbook:49
+msgid "<![CDATA[from Cat]]>"
+msgstr ""
+
+#: index.docbook:51
+msgid "Most of the time, you will need to assign an <emphasis>alias</emphasis>, since you will want to refer to the <literal>Cat</literal> in other parts of the query."
+msgstr ""
+
+#: index.docbook:57, index.docbook:372
+msgid "<![CDATA[from Cat as cat]]>"
+msgstr ""
+
+#: index.docbook:59
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so we could use that alias later in the query. The <literal>as</literal> keyword is optional; we could also write:"
+msgstr ""
+
+#: index.docbook:65
+msgid "<![CDATA[from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:67
+msgid "Multiple classes may appear, resulting in a cartesian product or \"cross\" join."
+msgstr ""
+
+#: index.docbook:71
+msgid "<![CDATA[from Formula, Parameter]]>"
+msgstr ""
+
+#: index.docbook:72
+msgid "<![CDATA[from Formula as form, Parameter as param]]>"
+msgstr ""
+
+#: index.docbook:74
+msgid "It is considered good practice to name query aliases using an initial lowercase, consistent with Java naming standards for local variables (eg. <literal>domesticCat</literal>)."
+msgstr ""
+
+#: index.docbook:83
+msgid "Associations and joins"
+msgstr ""
+
+#: index.docbook:85
+msgid "We may also assign aliases to associated entities, or even to elements of a collection of values, using a <literal>join</literal>."
+msgstr ""
+
+#: index.docbook:90
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join cat.mate as mate\n"
+ " left outer join cat.kittens as kitten]]>"
+msgstr ""
+
+#: index.docbook:92
+msgid "<![CDATA[from Cat as cat left join cat.mate.kittens as kittens]]>"
+msgstr ""
+
+#: index.docbook:94
+msgid "<![CDATA[from Formula form full join form.parameter param]]>"
+msgstr ""
+
+#: index.docbook:96
+msgid "The supported join types are borrowed from ANSI SQL"
+msgstr ""
+
+#: index.docbook:103
+msgid "inner join"
+msgstr ""
+
+#: index.docbook:108
+msgid "left outer join"
+msgstr ""
+
+#: index.docbook:113
+msgid "right outer join"
+msgstr ""
+
+#: index.docbook:117
+msgid "<literal>full join</literal> (not usually useful)"
+msgstr ""
+
+#: index.docbook:123
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " join cat.mate as mate\n"
+ " left join cat.kittens as kitten]]>"
+msgstr ""
+
+#: index.docbook:130
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " left join cat.kittens as kitten\n"
+ " with kitten.bodyWeight > 10.0]]>"
+msgstr ""
+
+#: index.docbook:137
+msgid "In addition, a \"fetch\" join allows associations or collections of values to be initialized along with their parent objects, using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\"/> for more information."
+msgstr ""
+
+#: index.docbook:145
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens]]>"
+msgstr ""
+
+#: index.docbook:147
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). Also, the associated objects are not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason we might need an alias is if we are recursively join fetching a further collection:"
+msgstr ""
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ " inner join fetch cat.mate\n"
+ " left join fetch cat.kittens child\n"
+ " left join fetch child.kittens]]>"
+msgstr ""
+
+#: index.docbook:157
+msgid "Note that the <literal>fetch</literal> construct may not be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). Nor should <literal>fetch</literal> be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal> as these operations are based on the result rows, which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you'd expect. Nor may <literal>fetch</literal> be used together with an ad hoc <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles also sometimes gives unexpected results for bag mappings, so be careful about how you formulate your queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr ""
+
+#: index.docbook:172
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties immediately (in the first query) using <literal>fetch all properties</literal>."
+msgstr ""
+
+#: index.docbook:178
+msgid "<![CDATA[from Document fetch all properties order by name]]>"
+msgstr ""
+
+#: index.docbook:179
+msgid "<![CDATA[from Document doc fetch all properties where lower(doc.name) like '%cats%']]>"
+msgstr ""
+
+#: index.docbook:184
+msgid "Forms of join syntax"
+msgstr ""
+
+#: index.docbook:186
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr ""
+
+#: index.docbook:190
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr ""
+
+#: index.docbook:195
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr ""
+
+#: index.docbook:202
+msgid "<![CDATA[from Cat as cat where cat.mate.name like '%s%']]>"
+msgstr ""
+
+#: index.docbook:206
+msgid "Refering to identifier property"
+msgstr ""
+
+#: index.docbook:208
+msgid "There are, generally speaking, 2 ways to refer to an entity's identifier property:"
+msgstr ""
+
+#: index.docbook:213
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that entity does not define a non-identifier property named id</emphasis>."
+msgstr ""
+
+#: index.docbook:220
+msgid "If the entity defines a named identifier property, you may use that property name."
+msgstr ""
+
+#: index.docbook:226
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named; otherwise, the special <literal>id</literal> property can be used to rerference the identifier property."
+msgstr ""
+
+#: index.docbook:233
+msgid "Note: this has changed significantly starting in version 3.2.2. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property no matter what its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr ""
+
+#: index.docbook:242
+msgid "The select clause"
+msgstr ""
+
+#: index.docbook:244
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider:"
+msgstr ""
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[select mate\n"
+ "from Cat as cat\n"
+ " inner join cat.mate as mate]]>"
+msgstr ""
+
+#: index.docbook:251
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. Actually, you may express this query more compactly as:"
+msgstr ""
+
+#: index.docbook:256
+msgid "<![CDATA[select cat.mate from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:258
+msgid "Queries may return properties of any value type including properties of component type:"
+msgstr ""
+
+#: index.docbook:262
+msgid ""
+ "<![CDATA[select cat.name from DomesticCat cat\n"
+ "where cat.name like 'fri%']]>"
+msgstr ""
+
+#: index.docbook:264
+msgid "<![CDATA[select cust.name.firstName from Customer as cust]]>"
+msgstr ""
+
+#: index.docbook:266
+msgid "Queries may return multiple objects and/or properties as an array of type <literal>Object[]</literal>,"
+msgstr ""
+
+#: index.docbook:271
+msgid ""
+ "<![CDATA[select mother, offspr, mate.name\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:273
+msgid "or as a <literal>List</literal>,"
+msgstr ""
+
+#: index.docbook:277
+msgid ""
+ "<![CDATA[select new list(mother, offspr, mate.name)\n"
+ "from DomesticCat as mother\n"
+ " inner join mother.mate as mate\n"
+ " left outer join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:279
+msgid "or as an actual typesafe Java object,"
+msgstr ""
+
+#: index.docbook:283
+msgid ""
+ "<![CDATA[select new Family(mother, mate, offspr)\n"
+ "from DomesticCat as mother\n"
+ " join mother.mate as mate\n"
+ " left join mother.kittens as offspr]]>"
+msgstr ""
+
+#: index.docbook:285
+msgid "assuming that the class <literal>Family</literal> has an appropriate constructor."
+msgstr ""
+
+#: index.docbook:289
+msgid "You may assign aliases to selected expressions using <literal>as</literal>:"
+msgstr ""
+
+#: index.docbook:293
+msgid ""
+ "<![CDATA[select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:295
+msgid "This is most useful when used together with <literal>select new map</literal>:"
+msgstr ""
+
+#: index.docbook:299
+msgid ""
+ "<![CDATA[select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:301
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr ""
+
+#: index.docbook:308
+msgid "Aggregate functions"
+msgstr ""
+
+#: index.docbook:310
+msgid "HQL queries may even return the results of aggregate functions on properties:"
+msgstr ""
+
+#: index.docbook:314
+msgid ""
+ "<![CDATA[select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
+ "from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:325
+msgid "The supported aggregate functions are"
+msgstr ""
+
+#: index.docbook:332
+msgid "avg(...), sum(...), min(...), max(...)"
+msgstr ""
+
+#: index.docbook:337
+msgid "count(*)"
+msgstr ""
+
+#: index.docbook:342
+msgid "count(...), count(distinct ...), count(all...)"
+msgstr ""
+
+#: index.docbook:347
+msgid "You may use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr ""
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[select cat.weight + sum(kitten.weight)\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.weight]]>"
+msgstr ""
+
+#: index.docbook:354
+msgid "<![CDATA[select firstName||' '||initial||' '||upper(lastName) from Person]]>"
+msgstr ""
+
+#: index.docbook:356
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords may be used and have the same semantics as in SQL."
+msgstr ""
+
+#: index.docbook:361
+msgid ""
+ "<![CDATA[select distinct cat.name from Cat cat\n"
+ "\n"
+ "select count(distinct cat.name), count(cat) from Cat cat]]>"
+msgstr ""
+
+#: index.docbook:366
+msgid "Polymorphic queries"
+msgstr ""
+
+#: index.docbook:368
+msgid "A query like:"
+msgstr ""
+
+#: index.docbook:374
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries may name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr ""
+
+#: index.docbook:382
+msgid "<![CDATA[from java.lang.Object o]]>"
+msgstr ""
+
+#: index.docbook:384
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
+msgstr ""
+
+#: index.docbook:389
+msgid "<![CDATA[from Named n, Named m where n.name = m.name]]>"
+msgstr ""
+
+#: index.docbook:391
+msgid "Note that these last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. (It also means you can't call these queries using <literal>Query.scroll()</literal>.)"
+msgstr ""
+
+#: index.docbook:400
+msgid "The where clause"
+msgstr ""
+
+#: index.docbook:402
+msgid "The <literal>where</literal> clause allows you to narrow the list of instances returned. If no alias exists, you may refer to properties by name:"
+msgstr ""
+
+#: index.docbook:407
+msgid "<![CDATA[from Cat where name='Fritz']]>"
+msgstr ""
+
+#: index.docbook:409
+msgid "If there is an alias, use a qualified property name:"
+msgstr ""
+
+#: index.docbook:413
+msgid "<![CDATA[from Cat as cat where cat.name='Fritz']]>"
+msgstr ""
+
+#: index.docbook:415
+msgid "returns instances of <literal>Cat</literal> named 'Fritz'."
+msgstr ""
+
+#: index.docbook:419
+msgid ""
+ "<![CDATA[select foo\n"
+ "from Foo foo, Bar bar\n"
+ "where foo.startDate = bar.date]]>"
+msgstr ""
+
+#: index.docbook:421
+msgid "will return all instances of <literal>Foo</literal> for which there exists an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider:"
+msgstr ""
+
+#: index.docbook:430
+msgid "<![CDATA[from Cat cat where cat.mate.name is not null]]>"
+msgstr ""
+
+#: index.docbook:432
+msgid "This query translates to an SQL query with a table (inner) join. If you were to write something like"
+msgstr ""
+
+#: index.docbook:437
+msgid ""
+ "<![CDATA[from Foo foo\n"
+ "where foo.bar.baz.customer.address.city is not null]]>"
+msgstr ""
+
+#: index.docbook:439
+msgid "you would end up with a query that would require four table joins in SQL."
+msgstr ""
+
+#: index.docbook:443
+msgid "The <literal>=</literal> operator may be used to compare not only properties, but also instances:"
+msgstr ""
+
+#: index.docbook:448
+msgid "<![CDATA[from Cat cat, Cat rival where cat.mate = rival.mate]]>"
+msgstr ""
+
+#: index.docbook:450
+msgid ""
+ "<![CDATA[select cat, mate\n"
+ "from Cat cat, Cat mate\n"
+ "where cat.mate = mate]]>"
+msgstr ""
+
+#: index.docbook:452
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\"/> for more information."
+msgstr ""
+
+#: index.docbook:458
+msgid ""
+ "<![CDATA[from Cat as cat where cat.id = 123\n"
+ "\n"
+ "from Cat as cat where cat.mate.id = 69]]>"
+msgstr ""
+
+#: index.docbook:460
+msgid "The second query is efficient. No table join is required!"
+msgstr ""
+
+#: index.docbook:464
+msgid "Properties of composite identifiers may also be used. Suppose <literal>Person</literal> has a composite identifier consisting of <literal>country</literal> and <literal>medicareNumber</literal>. Again, see <xref linkend=\"queryhql-identifier-property\"/> for more information regarding referencing identifier properties."
+msgstr ""
+
+#: index.docbook:471
+msgid ""
+ "<![CDATA[from bank.Person person\n"
+ "where person.id.country = 'AU'\n"
+ " and person.id.medicareNumber = 123456]]>"
+msgstr ""
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[from bank.Account account\n"
+ "where account.owner.id.country = 'AU'\n"
+ " and account.owner.id.medicareNumber = 123456]]>"
+msgstr ""
+
+#: index.docbook:475
+msgid "Once again, the second query requires no table join."
+msgstr ""
+
+#: index.docbook:479
+msgid "Likewise, the special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr ""
+
+#: index.docbook:485
+msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>"
+msgstr ""
+
+#: index.docbook:487
+msgid "You may also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-coomponents\"/> for more details."
+msgstr ""
+
+#: index.docbook:492
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal>, allowing us to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>)."
+msgstr ""
+
+#: index.docbook:498
+msgid ""
+ "<![CDATA[from AuditLog log, Payment payment\n"
+ "where log.item.class = 'Payment' and log.item.id = payment.id]]>"
+msgstr ""
+
+#: index.docbook:500
+msgid "Notice that <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr ""
+
+#: index.docbook:508
+msgid "Expressions"
+msgstr ""
+
+#: index.docbook:510
+msgid "Expressions allowed in the <literal>where</literal> clause include most of the kind of things you could write in SQL:"
+msgstr ""
+
+#: index.docbook:517
+msgid "mathematical operators <literal>+, -, *, /</literal>"
+msgstr ""
+
+#: index.docbook:522
+msgid "binary comparison operators <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr ""
+
+#: index.docbook:527
+msgid "logical operations <literal>and, or, not</literal>"
+msgstr ""
+
+#: index.docbook:532
+msgid "Parentheses <literal>( )</literal>, indicating grouping"
+msgstr ""
+
+#: index.docbook:537
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr ""
+
+#: index.docbook:550
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr ""
+
+#: index.docbook:556
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr ""
+
+#: index.docbook:561
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>"
+msgstr ""
+
+#: index.docbook:567
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, <literal>year(...)</literal>,"
+msgstr ""
+
+#: index.docbook:574
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr ""
+
+#: index.docbook:580
+msgid "<literal>coalesce()</literal> and <literal>nullif()</literal>"
+msgstr ""
+
+#: index.docbook:585
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
+msgstr ""
+
+#: index.docbook:591
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr ""
+
+#: index.docbook:599
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
+msgstr ""
+
+#: index.docbook:605
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions which may be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr ""
+
+#: index.docbook:613
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+msgstr ""
+
+#: index.docbook:619
+msgid "JDBC-style positional parameters <literal>?</literal>"
+msgstr ""
+
+#: index.docbook:624
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, <literal>:x1</literal>"
+msgstr ""
+
+#: index.docbook:629
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr ""
+
+#: index.docbook:635
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr ""
+
+#: index.docbook:641
+msgid "<literal>in</literal> and <literal>between</literal> may be used as follows:"
+msgstr ""
+
+#: index.docbook:645
+msgid "<![CDATA[from DomesticCat cat where cat.name between 'A' and 'B']]>"
+msgstr ""
+
+#: index.docbook:647
+msgid "<![CDATA[from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr ""
+
+#: index.docbook:649
+msgid "and the negated forms may be written"
+msgstr ""
+
+#: index.docbook:653
+msgid "<![CDATA[from DomesticCat cat where cat.name not between 'A' and 'B']]>"
+msgstr ""
+
+#: index.docbook:655
+msgid "<![CDATA[from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )]]>"
+msgstr ""
+
+#: index.docbook:657
+msgid "Likewise, <literal>is null</literal> and <literal>is not null</literal> may be used to test for null values."
+msgstr ""
+
+#: index.docbook:662
+msgid "Booleans may be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr ""
+
+#: index.docbook:667
+msgid "<![CDATA[<property name=\"hibernate.query.substitutions\">true 1, false 0</property>]]>"
+msgstr ""
+
+#: index.docbook:669
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr ""
+
+#: index.docbook:674
+msgid "<![CDATA[from Cat cat where cat.alive = true]]>"
+msgstr ""
+
+#: index.docbook:676
+msgid "You may test the size of a collection with the special property <literal>size</literal>, or the special <literal>size()</literal> function."
+msgstr ""
+
+#: index.docbook:681
+msgid "<![CDATA[from Cat cat where cat.kittens.size > 0]]>"
+msgstr ""
+
+#: index.docbook:683
+msgid "<![CDATA[from Cat cat where size(cat.kittens) > 0]]>"
+msgstr ""
+
+#: index.docbook:685
+msgid "For indexed collections, you may refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you may refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions."
+msgstr ""
+
+#: index.docbook:693
+msgid "<![CDATA[from Calendar cal where maxelement(cal.holidays) > current_date]]>"
+msgstr ""
+
+#: index.docbook:695
+msgid "<![CDATA[from Order order where maxindex(order.items) > 100]]>"
+msgstr ""
+
+#: index.docbook:697
+msgid "<![CDATA[from Order order where minelement(order.items) > 10000]]>"
+msgstr ""
+
+#: index.docbook:699
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below)."
+msgstr ""
+
+#: index.docbook:705
+msgid ""
+ "<![CDATA[select mother from Cat as mother, Cat as kit\n"
+ "where kit in elements(foo.kittens)]]>"
+msgstr ""
+
+#: index.docbook:707
+msgid ""
+ "<![CDATA[select p from NameList list, Person p\n"
+ "where p.name = some elements(list.names)]]>"
+msgstr ""
+
+#: index.docbook:709
+msgid "<![CDATA[from Cat cat where exists elements(cat.kittens)]]>"
+msgstr ""
+
+#: index.docbook:711
+msgid "<![CDATA[from Player p where 3 > all elements(p.scores)]]>"
+msgstr ""
+
+#: index.docbook:713
+msgid "<![CDATA[from Show show where 'fizard' in indices(show.acts)]]>"
+msgstr ""
+
+#: index.docbook:715
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - may only be used in the where clause in Hibernate3."
+msgstr ""
+
+#: index.docbook:722
+msgid "Elements of indexed collections (arrays, lists, maps) may be referred to by index (in a where clause only):"
+msgstr ""
+
+#: index.docbook:727
+msgid "<![CDATA[from Order order where order.items[0].id = 1234]]>"
+msgstr ""
+
+#: index.docbook:729
+msgid ""
+ "<![CDATA[select person from Person person, Calendar calendar\n"
+ "where calendar.holidays['national day'] = person.birthDay\n"
+ " and person.nationality.calendar = calendar]]>"
+msgstr ""
+
+#: index.docbook:731
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11]]>"
+msgstr ""
+
+#: index.docbook:733
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ maxindex(order.items) ] = item and order.id = 11]]>"
+msgstr ""
+
+#: index.docbook:735
+msgid "The expression inside <literal>[]</literal> may even be an arithmetic expression."
+msgstr ""
+
+#: index.docbook:739
+msgid ""
+ "<![CDATA[select item from Item item, Order order\n"
+ "where order.items[ size(order.items) - 1 ] = item]]>"
+msgstr ""
+
+#: index.docbook:741
+msgid "HQL also provides the built-in <literal>index()</literal> function, for elements of a one-to-many association or collection of values."
+msgstr ""
+
+#: index.docbook:746
+msgid ""
+ "<![CDATA[select item, index(item) from Order order\n"
+ " join order.items item\n"
+ "where index(item) < 5]]>"
+msgstr ""
+
+#: index.docbook:748
+msgid "Scalar SQL functions supported by the underlying database may be used"
+msgstr ""
+
+#: index.docbook:752
+msgid "<![CDATA[from DomesticCat cat where upper(cat.name) like 'FRI%']]>"
+msgstr ""
+
+#: index.docbook:754
+msgid "If you are not yet convinced by all this, think how much longer and less readable the following query would be in SQL:"
+msgstr ""
+
+#: index.docbook:759
+msgid ""
+ "<![CDATA[select cust\n"
+ "from Product prod,\n"
+ " Store store\n"
+ " inner join store.customers cust\n"
+ "where prod.name = 'widget'\n"
+ " and store.location.name in ( 'Melbourne', 'Sydney' )\n"
+ " and prod = all elements(cust.currentOrder.lineItems)]]>"
+msgstr ""
+
+#: index.docbook:761
+msgid "<emphasis>Hint:</emphasis> something like"
+msgstr ""
+
+#: index.docbook:765
+msgid ""
+ "<![CDATA[SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order\n"
+ "FROM customers cust,\n"
+ " stores store,\n"
+ " locations loc,\n"
+ " store_customers sc,\n"
+ " product prod\n"
+ "WHERE prod.name = 'widget'\n"
+ " AND store.loc_id = loc.id\n"
+ " AND loc.name IN ( 'Melbourne', 'Sydney' )\n"
+ " AND sc.store_id = store.id\n"
+ " AND sc.cust_id = cust.id\n"
+ " AND prod.id = ALL(\n"
+ " SELECT item.prod_id\n"
+ " FROM line_items item, orders o\n"
+ " WHERE item.order_id = o.id\n"
+ " AND cust.current_order = o.id\n"
+ " )]]>"
+msgstr ""
+
+#: index.docbook:770
+msgid "The order by clause"
+msgstr ""
+
+#: index.docbook:772
+msgid "The list returned by a query may be ordered by any property of a returned class or components:"
+msgstr ""
+
+#: index.docbook:776
+msgid ""
+ "<![CDATA[from DomesticCat cat\n"
+ "order by cat.name asc, cat.weight desc, cat.birthdate]]>"
+msgstr ""
+
+#: index.docbook:778
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr ""
+
+#: index.docbook:785
+msgid "The group by clause"
+msgstr ""
+
+#: index.docbook:787
+msgid "A query that returns aggregate values may be grouped by any property of a returned class or components:"
+msgstr ""
+
+#: index.docbook:791
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color]]>"
+msgstr ""
+
+#: index.docbook:793
+msgid ""
+ "<![CDATA[select foo.id, avg(name), max(name)\n"
+ "from Foo foo join foo.names name\n"
+ "group by foo.id]]>"
+msgstr ""
+
+#: index.docbook:795
+msgid "A <literal>having</literal> clause is also allowed."
+msgstr ""
+
+#: index.docbook:799
+msgid ""
+ "<![CDATA[select cat.color, sum(cat.weight), count(cat)\n"
+ "from Cat cat\n"
+ "group by cat.color\n"
+ "having cat.color in (eg.Color.TABBY, eg.Color.BLACK)]]>"
+msgstr ""
+
+#: index.docbook:801
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses, if supported by the underlying database (eg. not in MySQL)."
+msgstr ""
+
+#: index.docbook:807
+msgid ""
+ "<![CDATA[select cat\n"
+ "from Cat cat\n"
+ " join cat.kittens kitten\n"
+ "group by cat.id, cat.name, cat.other, cat.properties\n"
+ "having avg(kitten.weight) > 100\n"
+ "order by count(kitten) asc, sum(kitten.weight) desc]]>"
+msgstr ""
+
+#: index.docbook:809
+msgid "Note that neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause may contain arithmetic expressions. Also note that Hibernate currently does not expand a grouped entity, so you can't write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr ""
+
+#: index.docbook:821
+msgid "Subqueries"
+msgstr ""
+
+#: index.docbook:823
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr ""
+
+#: index.docbook:829
+msgid ""
+ "<![CDATA[from Cat as fatcat\n"
+ "where fatcat.weight > (\n"
+ " select avg(cat.weight) from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:831
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name = some (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:833
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not exists (\n"
+ " from Cat as mate where mate.mate = cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:835
+msgid ""
+ "<![CDATA[from DomesticCat as cat\n"
+ "where cat.name not in (\n"
+ " select name.nickName from Name as name\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:837
+msgid ""
+ "<![CDATA[select cat.id, (select max(kit.weight) from cat.kitten kit)\n"
+ "from Cat as cat]]>"
+msgstr ""
+
+#: index.docbook:839
+msgid "Note that HQL subqueries may occur only in the select or where clauses."
+msgstr ""
+
+#: index.docbook:843
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\"/> for more details."
+msgstr ""
+
+#: index.docbook:851
+msgid "HQL examples"
+msgstr ""
+
+#: index.docbook:853
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main selling points. Here are some example queries very similar to queries that I used on a recent project. Note that most queries you will write are much simpler than these!"
+msgstr ""
+
+#: index.docbook:859
+msgid "The following query returns the order id, number of items and total value of the order for all unpaid orders for a particular customer and given minimum total value, ordering the results by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr ""
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog.effectiveDate < sysdate\n"
+ " and catalog.effectiveDate >= all (\n"
+ " select cat.effectiveDate\n"
+ " from Catalog as cat\n"
+ " where cat.effectiveDate < sysdate\n"
+ " )\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+
+#: index.docbook:870
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr ""
+
+#: index.docbook:875
+msgid ""
+ "<![CDATA[select order.id, sum(price.amount), count(item)\n"
+ "from Order as order\n"
+ " join order.lineItems as item\n"
+ " join item.product as product,\n"
+ " Catalog as catalog\n"
+ " join catalog.prices as price\n"
+ "where order.paid = false\n"
+ " and order.customer = :customer\n"
+ " and price.product = product\n"
+ " and catalog = :currentCatalog\n"
+ "group by order\n"
+ "having sum(price.amount) > :minAmount\n"
+ "order by sum(price.amount) desc]]>"
+msgstr ""
+
+#: index.docbook:877
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr ""
+
+#: index.docbook:885
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ " join payment.statusChanges as statusChange\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or (\n"
+ " statusChange.timeStamp = (\n"
+ " select max(change.timeStamp)\n"
+ " from PaymentStatusChange change\n"
+ " where change.payment = payment\n"
+ " )\n"
+ " and statusChange.user <> :currentUser\n"
+ " )\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+
+#: index.docbook:887
+msgid "If I would have mapped the <literal>statusChanges</literal> collection as a list, instead of a set, the query would have been much simpler to write."
+msgstr ""
+
+#: index.docbook:892
+msgid ""
+ "<![CDATA[select count(payment), status.name\n"
+ "from Payment as payment\n"
+ " join payment.currentStatus as status\n"
+ "where payment.status.name <> PaymentStatus.AWAITING_APPROVAL\n"
+ " or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser\n"
+ "group by status.name, status.sortOrder\n"
+ "order by status.sortOrder]]>"
+msgstr ""
+
+#: index.docbook:894
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr ""
+
+#: index.docbook:903
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser in elements(account.holder.users)\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+
+#: index.docbook:905
+msgid "For some databases, we would need to do away with the (correlated) subselect."
+msgstr ""
+
+#: index.docbook:909
+msgid ""
+ "<![CDATA[select account, payment\n"
+ "from Account as account\n"
+ " join account.holder.users as user\n"
+ " left outer join account.payments as payment\n"
+ "where :currentUser = user\n"
+ " and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)\n"
+ "order by account.type.sortOrder, account.accountNumber, payment.dueDate]]>"
+msgstr ""
+
+#: index.docbook:914
+msgid "Bulk update and delete"
+msgstr ""
+
+#: index.docbook:916
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\"/> for details."
+msgstr ""
+
+#: index.docbook:924
+msgid "Tips & Tricks"
+msgstr ""
+
+#: index.docbook:926
+msgid "You can count the number of query results without actually returning them:"
+msgstr ""
+
+#: index.docbook:930
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue()]]>"
+msgstr ""
+
+#: index.docbook:932
+msgid "To order a result by the size of a collection, use the following query:"
+msgstr ""
+
+#: index.docbook:936
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "order by count(msg)]]>"
+msgstr ""
+
+#: index.docbook:938
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr ""
+
+#: index.docbook:943
+msgid "<![CDATA[from User usr where size(usr.messages) >= 1]]>"
+msgstr ""
+
+#: index.docbook:945
+msgid "If your database doesn't support subselects, use the following query:"
+msgstr ""
+
+#: index.docbook:949
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User usr.name\n"
+ " join usr.messages msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) >= 1]]>"
+msgstr ""
+
+#: index.docbook:951
+msgid "As this solution can't return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr ""
+
+#: index.docbook:956
+msgid ""
+ "<![CDATA[select usr.id, usr.name\n"
+ "from User as usr\n"
+ " left join usr.messages as msg\n"
+ "group by usr.id, usr.name\n"
+ "having count(msg) = 0]]>"
+msgstr ""
+
+#: index.docbook:958
+msgid "Properties of a JavaBean can be bound to named query parameters:"
+msgstr ""
+
+#: index.docbook:962
+msgid ""
+ "<![CDATA[Query q = s.createQuery(\"from foo Foo as foo where foo.name=:name and foo.size=:size\");\n"
+ "q.setProperties(fooBean); // fooBean has getName() and getSize()\n"
+ "List foos = q.list();]]>"
+msgstr ""
+
+#: index.docbook:964
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr ""
+
+#: index.docbook:968
+msgid ""
+ "<![CDATA[Query q = s.createFilter( collection, \"\" ); // the trivial filter\n"
+ "q.setMaxResults(PAGE_SIZE);\n"
+ "q.setFirstResult(PAGE_SIZE * pageNumber);\n"
+ "List page = q.list();]]>"
+msgstr ""
+
+#: index.docbook:970
+msgid "Collection elements may be ordered or grouped using a query filter:"
+msgstr ""
+
+#: index.docbook:974
+msgid ""
+ "<![CDATA[Collection orderedCollection = s.filter( collection, \"order by this.amount\" );\n"
+ "Collection counts = s.filter( collection, \"select this.type, count(this) group by this.type\" );]]>"
+msgstr ""
+
+#: index.docbook:976
+msgid "You can find the size of a collection without initializing it:"
+msgstr ""
+
+#: index.docbook:980
+msgid "<![CDATA[( (Integer) session.createQuery(\"select count(*) from ....\").iterate().next() ).intValue();]]>"
+msgstr ""
+
+#: index.docbook:985
+msgid "Components"
+msgstr ""
+
+#: index.docbook:987
+msgid "Components might be used in just about every way that simple value types can be used in HQL queries. They can appear in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:992, index.docbook:1038
+msgid "<![CDATA[select p.name from from Person p]]>"
+msgstr ""
+
+#: index.docbook:993
+msgid "<![CDATA[select p.name.first from from Person p]]>"
+msgstr ""
+
+#: index.docbook:995
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr ""
+
+#: index.docbook:1000
+msgid "<![CDATA[from from Person p where p.name = :name]]>"
+msgstr ""
+
+#: index.docbook:1001
+msgid "<![CDATA[from from Person p where p.name.first = :firstName]]>"
+msgstr ""
+
+#: index.docbook:1003
+msgid "Components can also be used in the <literal>order by</literal> clause:"
+msgstr ""
+
+#: index.docbook:1007
+msgid "<![CDATA[from from Person p order by p.name]]>"
+msgstr ""
+
+#: index.docbook:1008
+msgid "<![CDATA[from from Person p order by p.name.first]]>"
+msgstr ""
+
+#: index.docbook:1010
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\"/>row value constructors."
+msgstr ""
+
+#: index.docbook:1016
+msgid "Row value constructor syntax"
+msgstr ""
+
+#: index.docbook:1018
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax (sometimes called <literal>tuple</literal> syntax), even though the underlying database may not support that notion. Here we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr ""
+
+#: index.docbook:1025
+msgid "<![CDATA[from Person p where p.name.first='John' and p.name.last='Jingleheimer-Schmidt']]>"
+msgstr ""
+
+#: index.docbook:1027
+msgid "That's valid syntax, although a little verbose. It be nice to make this a bit more concise and use <literal>row value constructor</literal> syntax:"
+msgstr ""
+
+#: index.docbook:1032
+msgid "<![CDATA[from Person p where p.name=('John', 'Jingleheimer-Schmidt')]]>"
+msgstr ""
+
+#: index.docbook:1034
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Another time using <literal>row value constructor</literal> syntax can be beneficial is when using subqueries needing to compare against multiple values:"
+msgstr ""
+
+#: index.docbook:1045
+msgid ""
+ "<![CDATA[from Cat as cat\n"
+ "where not ( cat.name, cat.color ) in (\n"
+ " select cat.name, cat.color from DomesticCat cat\n"
+ ")]]>"
+msgstr ""
+
+#: index.docbook:1047
+msgid "One thing to consider when deciding if you want to use this syntax is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/query_sql.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/query_sql.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/query_sql.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,818 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Native SQL"
+msgstr ""
+
+#: index.docbook:7
+msgid "You may also express queries in the native SQL dialect of your database. This is useful if you want to utilize database specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr ""
+
+#: index.docbook:13
+msgid "Hibernate3 allows you to specify handwritten SQL (including stored procedures) for all create, update, delete, and load operations."
+msgstr ""
+
+#: index.docbook:17
+msgid "Using a <literal>SQLQuery</literal>"
+msgstr ""
+
+#: index.docbook:19
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following describes how to use this API for querying."
+msgstr ""
+
+#: index.docbook:25
+msgid "Scalar queries"
+msgstr ""
+
+#: index.docbook:27
+msgid "The most basic SQL query is to get a list of scalars (values)."
+msgstr ""
+
+#: index.docbook:30
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").list();\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").list();\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:32
+msgid "These will both return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr ""
+
+#: index.docbook:37
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal> or simply to be more explicit in what is returned one can use <literal>addScalar()</literal>."
+msgstr ""
+
+#: index.docbook:41
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\", Hibernate.STRING)\n"
+ " .addScalar(\"BIRTHDATE\", Hibernate.DATE)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:43, index.docbook:89, index.docbook:170, index.docbook:321
+msgid "This query specified:"
+msgstr ""
+
+#: index.docbook:47, index.docbook:93, index.docbook:325
+msgid "the SQL query string"
+msgstr ""
+
+#: index.docbook:51
+msgid "the columns and types to return"
+msgstr ""
+
+#: index.docbook:55
+msgid "This will still return Object arrays, but now it will not use <literal>ResultSetMetdata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr ""
+
+#: index.docbook:63
+msgid "It is possible to leave out the type information for all or some of the scalars."
+msgstr ""
+
+#: index.docbook:66
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\")\n"
+ " .addScalar(\"ID\", Hibernate.LONG)\n"
+ " .addScalar(\"NAME\")\n"
+ " .addScalar(\"BIRTHDATE\")\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:68
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to decide the type of NAME and BIRTHDATE where as the type of ID is explicitly specified."
+msgstr ""
+
+#: index.docbook:72
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped or does not result in the expected type it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr ""
+
+#: index.docbook:80
+msgid "Entity queries"
+msgstr ""
+
+#: index.docbook:82
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr ""
+
+#: index.docbook:87
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT * FROM CATS\").addEntity(Cat.class);\n"
+ "sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:97
+msgid "the entity returned by the query"
+msgstr ""
+
+#: index.docbook:101
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr ""
+
+#: index.docbook:105
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr ""
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS\").addEntity(Cat.class);\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:115
+msgid "This will allow cat.getDog() to function properly."
+msgstr ""
+
+#: index.docbook:119
+msgid "Handling associations and collections"
+msgstr ""
+
+#: index.docbook:121
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dog\");\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "In this example the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that we added a alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr ""
+
+#: index.docbook:136
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addJoin(\"cat.dogs\");\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:138
+msgid "At this stage we are reaching the limits of what is possible with native queries without starting to enhance the sql queries to make them usable in Hibernate; the problems starts to arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr ""
+
+#: index.docbook:146
+msgid "Returning multiple entities"
+msgstr ""
+
+#: index.docbook:148
+msgid "Until now the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries which join multiple tables, since the same column names may appear in more than one table."
+msgstr ""
+
+#: index.docbook:153
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
+msgstr ""
+
+#: index.docbook:156
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT c.*, m.* FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:158
+msgid "The intention for this query is to return two Cat instances per row, a cat and its mother. This will fail since there is a conflict of names since they are mapped to the same column names and on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specificed in the mappings (\"ID\" and \"NAME\")."
+msgstr ""
+
+#: index.docbook:165
+msgid "The following form is not vulnerable to column name duplication:"
+msgstr ""
+
+#: index.docbook:168
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT {cat.*}, {mother.*} FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class)\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:174
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
+msgstr ""
+
+#: index.docbook:179
+msgid "the entities returned by the query"
+msgstr ""
+
+#: index.docbook:183
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you may list the columns explicity, but even in this case we let Hibernate inject the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, we retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. Notice that we may even use the property aliases in the where clause if we like."
+msgstr ""
+
+#: index.docbook:192
+msgid ""
+ "<![CDATA[String sql = \"SELECT ID as {c.id}, NAME as {c.name}, \" + \n"
+ " \"BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} \" +\n"
+ " \"FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID\";\n"
+ "\n"
+ "List loggedCats = sess.createSQLQuery(sql)\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ " .addEntity(\"mother\", Cat.class).list()\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:195
+msgid "Alias and property references"
+msgstr ""
+
+#: index.docbook:197
+msgid "For most cases the above alias injection is needed, but for queries relating to more complex mappings like composite properties, inheritance discriminators, collections etc. there are some specific aliases to use to allow Hibernate to inject the proper aliases."
+msgstr ""
+
+#: index.docbook:202
+msgid "The following table shows the different possibilities of using the alias injection. Note: the alias names in the result are examples, each alias will have a unique and probably different name when used."
+msgstr ""
+
+#: index.docbook:208
+msgid "Alias injection names"
+msgstr ""
+
+#: index.docbook:219
+msgid "Description"
+msgstr ""
+
+#: index.docbook:221
+msgid "Syntax"
+msgstr ""
+
+#: index.docbook:223
+msgid "Example"
+msgstr ""
+
+#: index.docbook:229
+msgid "A simple property"
+msgstr ""
+
+#: index.docbook:231
+msgid "{[aliasname].[propertyname]"
+msgstr ""
+
+#: index.docbook:233
+msgid "A_NAME as {item.name}"
+msgstr ""
+
+#: index.docbook:237
+msgid "A composite property"
+msgstr ""
+
+#: index.docbook:239
+msgid "{[aliasname].[componentname].[propertyname]}"
+msgstr ""
+
+#: index.docbook:241
+msgid "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+msgstr ""
+
+#: index.docbook:246
+msgid "Discriminator of an entity"
+msgstr ""
+
+#: index.docbook:248
+msgid "{[aliasname].class}"
+msgstr ""
+
+#: index.docbook:250
+msgid "DISC as {item.class}"
+msgstr ""
+
+#: index.docbook:254
+msgid "All properties of an entity"
+msgstr ""
+
+#: index.docbook:256, index.docbook:304
+msgid "{[aliasname].*}"
+msgstr ""
+
+#: index.docbook:258
+msgid "{item.*}"
+msgstr ""
+
+#: index.docbook:262
+msgid "A collection key"
+msgstr ""
+
+#: index.docbook:264
+msgid "{[aliasname].key}"
+msgstr ""
+
+#: index.docbook:266
+msgid "ORGID as {coll.key}"
+msgstr ""
+
+#: index.docbook:270
+msgid "The id of an collection"
+msgstr ""
+
+#: index.docbook:272
+msgid "{[aliasname].id}"
+msgstr ""
+
+#: index.docbook:274
+msgid "EMPID as {coll.id}"
+msgstr ""
+
+#: index.docbook:278
+msgid "The element of an collection"
+msgstr ""
+
+#: index.docbook:280
+msgid "{[aliasname].element}"
+msgstr ""
+
+#: index.docbook:282
+msgid "XID as {coll.element}"
+msgstr ""
+
+#: index.docbook:286
+msgid "roperty of the element in the collection"
+msgstr ""
+
+#: index.docbook:288
+msgid "{[aliasname].element.[propertyname]}"
+msgstr ""
+
+#: index.docbook:290
+msgid "NAME as {coll.element.name}"
+msgstr ""
+
+#: index.docbook:294
+msgid "All properties of the element in the collection"
+msgstr ""
+
+#: index.docbook:296
+msgid "{[aliasname].element.*}"
+msgstr ""
+
+#: index.docbook:298
+msgid "{coll.element.*}"
+msgstr ""
+
+#: index.docbook:302
+msgid "All properties of the the collection"
+msgstr ""
+
+#: index.docbook:306
+msgid "{coll.*}"
+msgstr ""
+
+#: index.docbook:315
+msgid "Returning non-managed entities"
+msgstr ""
+
+#: index.docbook:317
+msgid "It is possible to apply a ResultTransformer to native sql queries. Allowing it to e.g. return non-managed entities."
+msgstr ""
+
+#: index.docbook:319
+msgid ""
+ "<![CDATA[sess.createSQLQuery(\"SELECT NAME, BIRTHDATE FROM CATS\")\n"
+ " .setResultTransformer(Transformers.aliasToBean(CatDTO.class))]]>"
+msgstr ""
+
+#: index.docbook:329
+msgid "a result transformer"
+msgstr ""
+
+#: index.docbook:333
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr ""
+
+#: index.docbook:340
+msgid "Handling inheritance"
+msgstr ""
+
+#: index.docbook:342
+msgid "Native sql queries which query for entities that is mapped as part of an inheritance must include all properties for the baseclass and all it subclasses."
+msgstr ""
+
+#: index.docbook:348
+msgid "Parameters"
+msgstr ""
+
+#: index.docbook:350
+msgid "Native sql queries support positional as well as named parameters:"
+msgstr ""
+
+#: index.docbook:353
+msgid ""
+ "<![CDATA[Query query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like ?\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(0, \"Pus%\").list();\n"
+ " \n"
+ "query = sess.createSQLQuery(\"SELECT * FROM CATS WHERE NAME like :name\").addEntity(Cat.class);\n"
+ "List pusList = query.setString(\"name\", \"Pus%\").list(); ]]>"
+msgstr ""
+
+#: index.docbook:361
+msgid "Named SQL queries"
+msgstr ""
+
+#: index.docbook:363
+msgid "Named SQL queries may be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, we do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr ""
+
+#: index.docbook:368
+msgid ""
+ "<![CDATA[<sql-query name=\"persons\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex}\n"
+ " FROM PERSON person\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:370
+msgid ""
+ "<![CDATA[List people = sess.getNamedQuery(\"persons\")\n"
+ " .setString(\"namePattern\", namePattern)\n"
+ " .setMaxResults(50)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:372
+msgid "The <literal><return-join></literal> and <literal><load-collection></literal> elements are used to join associations and define queries which initialize collections, respectively."
+msgstr ""
+
+#: index.docbook:377
+msgid ""
+ "<![CDATA[<sql-query name=\"personsWith\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:379
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr ""
+
+#: index.docbook:383
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return-scalar column=\"name\" type=\"string\"/>\n"
+ " <return-scalar column=\"age\" type=\"long\"/>\n"
+ " SELECT p.NAME AS name,\n"
+ " p.AGE AS age,\n"
+ " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:385
+msgid "You can externalize the resultset mapping informations in a <literal><resultset></literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr ""
+
+#: index.docbook:390
+msgid ""
+ "<![CDATA[<resultset name=\"personAddress\">\n"
+ " <return alias=\"person\" class=\"eg.Person\"/>\n"
+ " <return-join alias=\"address\" property=\"person.mailingAddress\"/>\n"
+ "</resultset>\n"
+ "\n"
+ "<sql-query name=\"personsWith\" resultset-ref=\"personAddress\">\n"
+ " SELECT person.NAME AS {person.name},\n"
+ " person.AGE AS {person.age},\n"
+ " person.SEX AS {person.sex},\n"
+ " address.STREET AS {address.street},\n"
+ " address.CITY AS {address.city},\n"
+ " address.STATE AS {address.state},\n"
+ " address.ZIP AS {address.zip}\n"
+ " FROM PERSON person\n"
+ " JOIN ADDRESS address\n"
+ " ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'\n"
+ " WHERE person.NAME LIKE :namePattern\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:392
+msgid "You can alternatively use the resultset mapping information in your hbm files directly in java code."
+msgstr ""
+
+#: index.docbook:395
+msgid ""
+ "<![CDATA[List cats = sess.createSQLQuery(\n"
+ " \"select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id\"\n"
+ " )\n"
+ " .setResultSetMapping(\"catAndKitten\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:398
+msgid "Using return-property to explicitly specify column/alias names"
+msgstr ""
+
+#: index.docbook:401
+msgid "With <literal><return-property></literal> you can explicitly tell Hibernate what column aliases to use, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases."
+msgstr ""
+
+#: index.docbook:406
+msgid ""
+ "<![CDATA[<sql-query name=\"mySqlQuery\">\n"
+ " <return alias=\"person\" class=\"eg.Person\">\n"
+ " <return-property name=\"name\" column=\"myName\"/>\n"
+ " <return-property name=\"age\" column=\"myAge\"/>\n"
+ " <return-property name=\"sex\" column=\"mySex\"/>\n"
+ " </return>\n"
+ " SELECT person.NAME AS myName,\n"
+ " person.AGE AS myAge,\n"
+ " person.SEX AS mySex,\n"
+ " FROM PERSON person WHERE person.NAME LIKE :name\n"
+ "</sql-query>\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:408
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which can not allow fine grained control of multi-column properties."
+msgstr ""
+
+#: index.docbook:413
+msgid ""
+ "<![CDATA[<sql-query name=\"organizationCurrentEmployments\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " <return-property name=\"endDate\" column=\"myEndDate\"/>\n"
+ " </return>\n"
+ " SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},\n"
+ " STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},\n"
+ " REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT\n"
+ " WHERE EMPLOYER = :id AND ENDDATE IS NULL\n"
+ " ORDER BY STARTDATE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:415
+msgid "Notice that in this example we used <literal><return-property></literal> in combination with the <literal>{}</literal>-syntax for injection. Allowing users to choose how they want to refer column and properties."
+msgstr ""
+
+#: index.docbook:420
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr ""
+
+#: index.docbook:426
+msgid "Using stored procedures for querying"
+msgstr ""
+
+#: index.docbook:428
+msgid "Hibernate 3 introduces support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr ""
+
+#: index.docbook:434
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION selectAllEmployments\n"
+ " RETURN SYS_REFCURSOR\n"
+ "AS\n"
+ " st_cursor SYS_REFCURSOR;\n"
+ "BEGIN\n"
+ " OPEN st_cursor FOR\n"
+ " SELECT EMPLOYEE, EMPLOYER,\n"
+ " STARTDATE, ENDDATE,\n"
+ " REGIONCODE, EID, VALUE, CURRENCY\n"
+ " FROM EMPLOYMENT;\n"
+ " RETURN st_cursor;\n"
+ " END;]]>"
+msgstr ""
+
+#: index.docbook:436
+msgid "To use this query in Hibernate you need to map it via a named query."
+msgstr ""
+
+#: index.docbook:439
+msgid ""
+ "<![CDATA[<sql-query name=\"selectAllEmployees_SP\" callable=\"true\">\n"
+ " <return alias=\"emp\" class=\"Employment\">\n"
+ " <return-property name=\"employee\" column=\"EMPLOYEE\"/>\n"
+ " <return-property name=\"employer\" column=\"EMPLOYER\"/>\n"
+ " <return-property name=\"startDate\" column=\"STARTDATE\"/>\n"
+ " <return-property name=\"endDate\" column=\"ENDDATE\"/>\n"
+ " <return-property name=\"regionCode\" column=\"REGIONCODE\"/>\n"
+ " <return-property name=\"id\" column=\"EID\"/>\n"
+ " <return-property name=\"salary\">\n"
+ " <return-column name=\"VALUE\"/>\n"
+ " <return-column name=\"CURRENCY\"/>\n"
+ " </return-property>\n"
+ " </return>\n"
+ " { ? = call selectAllEmployments() }\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:441
+msgid "Notice stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr ""
+
+#: index.docbook:446
+msgid "Rules/limitations for using stored procedures"
+msgstr ""
+
+#: index.docbook:448
+msgid "To use stored procedures with Hibernate the procedures/functions have to follow some rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr ""
+
+#: index.docbook:455
+msgid "Stored procedure queries can't be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr ""
+
+#: index.docbook:463
+msgid "For Oracle the following rules apply:"
+msgstr ""
+
+#: index.docbook:467
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type, see Oracle literature."
+msgstr ""
+
+#: index.docbook:476
+msgid "For Sybase or MS SQL server the following rules apply:"
+msgstr ""
+
+#: index.docbook:480
+msgid "The procedure must return a result set. Note that since these servers can/will return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr ""
+
+#: index.docbook:488
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr ""
+
+#: index.docbook:498
+msgid "Custom SQL for create, update and delete"
+msgstr ""
+
+#: index.docbook:500
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr ""
+
+#: index.docbook:508
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>\n"
+ " <sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>\n"
+ " <sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:510
+msgid "The SQL is directly executed in your database, so you are free to use any dialect you like. This will of course reduce the portability of your mapping if you use database specific SQL."
+msgstr ""
+
+#: index.docbook:514
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
+msgstr ""
+
+#: index.docbook:517
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <sql-insert callable=\"true\">{call createPerson (?, ?)}</sql-insert>\n"
+ " <sql-delete callable=\"true\">{? = call deletePerson (?)}</sql-delete>\n"
+ " <sql-update callable=\"true\">{? = call updatePerson (?, ?)}</sql-update>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:519
+msgid "The order of the positional parameters are currently vital, as they must be in the same sequence as Hibernate expects them."
+msgstr ""
+
+#: index.docbook:522
+msgid "You can see the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled Hibernate will print out the static SQL that is used to create, update, delete etc. entities. (To see the expected sequence, remember to not include your custom SQL in the mapping files as that will override the Hibernate generated static sql.)"
+msgstr ""
+
+#: index.docbook:529
+msgid "The stored procedures are in most cases (read: better do it than not) required to return the number of rows inserted/updated/deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
+msgstr ""
+
+#: index.docbook:535
+msgid ""
+ "<![CDATA[CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)\n"
+ " RETURN NUMBER IS\n"
+ "BEGIN\n"
+ "\n"
+ " update PERSON\n"
+ " set\n"
+ " NAME = uname,\n"
+ " where\n"
+ " ID = uid;\n"
+ "\n"
+ " return SQL%ROWCOUNT;\n"
+ "\n"
+ "END updatePerson;]]>"
+msgstr ""
+
+#: index.docbook:539
+msgid "Custom SQL for loading"
+msgstr ""
+
+#: index.docbook:541
+msgid "You may also declare your own SQL (or HQL) queries for entity loading:"
+msgstr ""
+
+#: index.docbook:544
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/>\n"
+ " SELECT NAME AS {pers.name}, ID AS {pers.id}\n"
+ " FROM PERSON\n"
+ " WHERE ID=?\n"
+ " FOR UPDATE\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:546
+msgid "This is just a named query declaration, as discussed earlier. You may reference this named query in a class mapping:"
+msgstr ""
+
+#: index.docbook:549
+msgid ""
+ "<![CDATA[<class name=\"Person\">\n"
+ " <id name=\"id\">\n"
+ " <generator class=\"increment\"/>\n"
+ " </id>\n"
+ " <property name=\"name\" not-null=\"true\"/>\n"
+ " <loader query-ref=\"person\"/>\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:551
+msgid "This even works with stored procedures."
+msgstr ""
+
+#: index.docbook:553
+msgid "You may even define a query for collection loading:"
+msgstr ""
+
+#: index.docbook:555
+msgid ""
+ "<![CDATA[<set name=\"employments\" inverse=\"true\">\n"
+ " <key/>\n"
+ " <one-to-many class=\"Employment\"/>\n"
+ " <loader query-ref=\"employments\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:557
+msgid ""
+ "<![CDATA[<sql-query name=\"employments\">\n"
+ " <load-collection alias=\"emp\" role=\"Person.employments\"/>\n"
+ " SELECT {emp.*}\n"
+ " FROM EMPLOYMENT emp\n"
+ " WHERE EMPLOYER = :id\n"
+ " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n"
+ "</sql-query>]]>"
+msgstr ""
+
+#: index.docbook:559
+msgid "You could even define an entity loader that loads a collection by join fetching:"
+msgstr ""
+
+#: index.docbook:562
+msgid ""
+ "<![CDATA[<sql-query name=\"person\">\n"
+ " <return alias=\"pers\" class=\"Person\"/>\n"
+ " <return-join alias=\"emp\" property=\"pers.employments\"/>\n"
+ " SELECT NAME AS {pers.*}, {emp.*}\n"
+ " FROM PERSON pers\n"
+ " LEFT OUTER JOIN EMPLOYMENT emp\n"
+ " ON pers.ID = emp.PERSON_ID\n"
+ " WHERE ID=?\n"
+ "</sql-query>]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/quickstart.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/quickstart.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/quickstart.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,12 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/session_api.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/session_api.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/session_api.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,982 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Working with objects"
+msgstr ""
+
+#: index.docbook:7
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a very natural object-oriented view of persistence in Java applications."
+msgstr ""
+
+#: index.docbook:16
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr ""
+
+#: index.docbook:24
+msgid "Hibernate object states"
+msgstr ""
+
+#: index.docbook:26
+msgid "Hibernate defines and supports the following object states:"
+msgstr ""
+
+#: index.docbook:32
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr ""
+
+#: index.docbook:44
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers don't execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr ""
+
+#: index.docbook:55
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e. a unit of work from the point of view of the user."
+msgstr ""
+
+#: index.docbook:69
+msgid "We'll now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr ""
+
+#: index.docbook:77
+msgid "Making objects persistent"
+msgstr ""
+
+#: index.docbook:79
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr ""
+
+#: index.docbook:86
+msgid ""
+ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
+ "fritz.setColor(Color.GINGER);\n"
+ "fritz.setSex('M');\n"
+ "fritz.setName(\"Fritz\");\n"
+ "Long generatedId = (Long) sess.save(fritz);]]>"
+msgstr ""
+
+#: index.docbook:88
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You may also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr ""
+
+#: index.docbook:100
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it doesn't guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr ""
+
+#: index.docbook:111
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr ""
+
+#: index.docbook:121
+msgid "Alternatively, you may assign the identifier using an overloaded version of <literal>save()</literal>."
+msgstr ""
+
+#: index.docbook:126
+msgid ""
+ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
+ "pk.setColor(Color.TABBY);\n"
+ "pk.setSex('F');\n"
+ "pk.setName(\"PK\");\n"
+ "pk.setKittens( new HashSet() );\n"
+ "pk.addKitten(fritz);\n"
+ "sess.save( pk, new Long(1234) );]]>"
+msgstr ""
+
+#: index.docbook:128
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects may be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr ""
+
+#: index.docbook:138
+msgid "Usually you don't bother with this detail, as you'll very likely use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations don't occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:149
+msgid "Loading an object"
+msgstr ""
+
+#: index.docbook:151
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> gives you a way to retrieve a persistent instance if you already know its identifier. <literal>load()</literal> takes a class object and will load the state into a newly instantiated instance of that class, in persistent state."
+msgstr ""
+
+#: index.docbook:158
+msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
+msgstr ""
+
+#: index.docbook:160
+msgid ""
+ "<![CDATA[// you need to wrap primitive identifiers\n"
+ "long id = 1234;\n"
+ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) );]]>"
+msgstr ""
+
+#: index.docbook:162
+msgid "Alternatively, you can load state into a given instance:"
+msgstr ""
+
+#: index.docbook:166
+msgid ""
+ "<![CDATA[Cat cat = new DomesticCat();\n"
+ "// load pk's state into cat\n"
+ "sess.load( cat, new Long(pkId) );\n"
+ "Set kittens = cat.getKittens();]]>"
+msgstr ""
+
+#: index.docbook:168
+msgid "Note that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This behaviour is very useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr ""
+
+#: index.docbook:179
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method, which hits the database immediately and returns null if there is no matching row."
+msgstr ""
+
+#: index.docbook:185
+msgid ""
+ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
+ "if (cat==null) {\n"
+ " cat = new Cat();\n"
+ " sess.save(cat, id);\n"
+ "}\n"
+ "return cat;]]>"
+msgstr ""
+
+#: index.docbook:187
+msgid "You may even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr ""
+
+#: index.docbook:192
+msgid "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
+msgstr ""
+
+#: index.docbook:194
+msgid "Note that any associated instances or contained collections are <emphasis>not</emphasis> selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr ""
+
+#: index.docbook:201
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr ""
+
+#: index.docbook:207
+msgid ""
+ "<![CDATA[sess.save(cat);\n"
+ "sess.flush(); //force the SQL INSERT\n"
+ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
+msgstr ""
+
+#: index.docbook:209
+msgid "An important question usually appears at this point: How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis> and is explained in <xref linkend=\"performance-fetching\"/>."
+msgstr ""
+
+#: index.docbook:219
+msgid "Querying"
+msgstr ""
+
+#: index.docbook:221
+msgid "If you don't know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You may also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr ""
+
+#: index.docbook:231
+msgid "Executing queries"
+msgstr ""
+
+#: index.docbook:233
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr ""
+
+#: index.docbook:240
+msgid ""
+ "<![CDATA[List cats = session.createQuery(\n"
+ " \"from Cat as cat where cat.birthdate < ?\")\n"
+ " .setDate(0, date)\n"
+ " .list();\n"
+ "\n"
+ "List mothers = session.createQuery(\n"
+ " \"select mother from Cat as cat join cat.mother as mother where cat.name = ?\")\n"
+ " .setString(0, name)\n"
+ " .list();\n"
+ "\n"
+ "List kittens = session.createQuery(\n"
+ " \"from Cat as cat where cat.mother = ?\")\n"
+ " .setEntity(0, pk)\n"
+ " .list();\n"
+ "\n"
+ "Cat mother = (Cat) session.createQuery(\n"
+ " \"select cat.mother from Cat as cat where cat = ?\")\n"
+ " .setEntity(0, izi)\n"
+ " .uniqueResult();]]\n"
+ "\n"
+ "Query mothersWithKittens = (Cat) session.createQuery(\n"
+ " \"select mother from Cat as mother left join fetch mother.kittens\");\n"
+ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
+msgstr ""
+
+#: index.docbook:242
+msgid "A query is usually executed by invoking <literal>list()</literal>, the result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Note that queries that make use of eager fetching of collections usually return duplicates of the root objects (but with their collections initialized). You can filter these duplicates simply through a <literal>Set</literal>."
+msgstr ""
+
+#: index.docbook:254
+msgid "Iterating results"
+msgstr ""
+
+#: index.docbook:256
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will only usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr ""
+
+#: index.docbook:268
+msgid ""
+ "<![CDATA[// fetch ids\n"
+ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\").iterate();\n"
+ "while ( iter.hasNext() ) {\n"
+ " Qux qux = (Qux) iter.next(); // fetch the object\n"
+ " // something we couldnt express in the query\n"
+ " if ( qux.calculateComplicatedAlgorithm() ) {\n"
+ " // delete the current instance\n"
+ " iter.remove();\n"
+ " // dont need to process the rest\n"
+ " break;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:272
+msgid "Queries that return tuples"
+msgstr ""
+
+#: index.docbook:274
+msgid "Hibernate queries sometimes return tuples of objects, in which case each tuple is returned as an array:"
+msgstr ""
+
+#: index.docbook:279
+msgid ""
+ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
+ " \"select kitten, mother from Cat kitten join kitten.mother mother\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( kittensAndMothers.hasNext() ) {\n"
+ " Object[] tuple = (Object[]) kittensAndMothers.next();\n"
+ " Cat kitten = (Cat) tuple[0];\n"
+ " Cat mother = (Cat) tuple[1];\n"
+ " ....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:284
+msgid "Scalar results"
+msgstr ""
+
+#: index.docbook:286
+msgid "Queries may specify a property of a class in the <literal>select</literal> clause. They may even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results (and not entities in persistent state)."
+msgstr ""
+
+#: index.docbook:292
+msgid ""
+ "<![CDATA[Iterator results = sess.createQuery(\n"
+ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat \" +\n"
+ " \"group by cat.color\")\n"
+ " .list()\n"
+ " .iterator();\n"
+ "\n"
+ "while ( results.hasNext() ) {\n"
+ " Object[] row = (Object[]) results.next();\n"
+ " Color type = (Color) row[0];\n"
+ " Date oldest = (Date) row[1];\n"
+ " Integer count = (Integer) row[2];\n"
+ " .....\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:297
+msgid "Bind parameters"
+msgstr ""
+
+#: index.docbook:299
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are:"
+msgstr ""
+
+#: index.docbook:309
+msgid "named parameters are insensitive to the order they occur in the query string"
+msgstr ""
+
+#: index.docbook:315
+msgid "they may occur multiple times in the same query"
+msgstr ""
+
+#: index.docbook:320
+msgid "they are self-documenting"
+msgstr ""
+
+#: index.docbook:326
+msgid ""
+ "<![CDATA[//named parameter (preferred)\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name\");\n"
+ "q.setString(\"name\", \"Fritz\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+
+#: index.docbook:328
+msgid ""
+ "<![CDATA[//positional parameter\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
+ "q.setString(0, \"Izi\");\n"
+ "Iterator cats = q.iterate();]]>"
+msgstr ""
+
+#: index.docbook:330
+msgid ""
+ "<![CDATA[//named parameter list\n"
+ "List names = new ArrayList();\n"
+ "names.add(\"Izi\");\n"
+ "names.add(\"Fritz\");\n"
+ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name in (:namesList)\");\n"
+ "q.setParameterList(\"namesList\", names);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:335
+msgid "Pagination"
+msgstr ""
+
+#: index.docbook:337
+msgid "If you need to specify bounds upon your result set (the maximum number of rows you want to retrieve and / or the first row you want to retrieve) you should use methods of the <literal>Query</literal> interface:"
+msgstr ""
+
+#: index.docbook:343
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
+ "q.setFirstResult(20);\n"
+ "q.setMaxResults(10);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:345
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr ""
+
+#: index.docbook:353
+msgid "Scrollable iteration"
+msgstr ""
+
+#: index.docbook:355
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface may be used to obtain a <literal>ScrollableResults</literal> object, which allows flexible navigation of the query results."
+msgstr ""
+
+#: index.docbook:362
+msgid ""
+ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from DomesticCat cat \" +\n"
+ " \"order by cat.name\");\n"
+ "ScrollableResults cats = q.scroll();\n"
+ "if ( cats.first() ) {\n"
+ "\n"
+ " // find the first name on each page of an alphabetical list of cats by name\n"
+ " firstNamesOfPages = new ArrayList();\n"
+ " do {\n"
+ " String name = cats.getString(0);\n"
+ " firstNamesOfPages.add(name);\n"
+ " }\n"
+ " while ( cats.scroll(PAGE_SIZE) );\n"
+ "\n"
+ " // Now get the first page of cats\n"
+ " pageOfCats = new ArrayList();\n"
+ " cats.beforeFirst();\n"
+ " int i=0;\n"
+ " while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );\n"
+ "\n"
+ "}\n"
+ "cats.close()]]>"
+msgstr ""
+
+#: index.docbook:364
+msgid "Note that an open database connection (and cursor) is required for this functionality, use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr ""
+
+#: index.docbook:373
+msgid "Externalizing named queries"
+msgstr ""
+
+#: index.docbook:375
+msgid "You may also define named queries in the mapping document. (Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup.)"
+msgstr ""
+
+#: index.docbook:381
+msgid ""
+ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
+ " from eg.DomesticCat as cat\n"
+ " where cat.name = ?\n"
+ " and cat.weight > ?\n"
+ "] ]></query>]]>"
+msgstr ""
+
+#: index.docbook:383
+msgid "Parameter binding and executing is done programatically:"
+msgstr ""
+
+#: index.docbook:387
+msgid ""
+ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
+ "q.setString(0, name);\n"
+ "q.setInt(1, minWeight);\n"
+ "List cats = q.list();]]>"
+msgstr ""
+
+#: index.docbook:389
+msgid "Note that the actual program code is independent of the query language that is used, you may also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr ""
+
+#: index.docbook:395
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class, for example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr ""
+
+#: index.docbook:408
+msgid "Filtering collections"
+msgstr ""
+
+#: index.docbook:409
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that may be applied to a persistent collection or array. The query string may refer to <literal>this</literal>, meaning the current collection element."
+msgstr ""
+
+#: index.docbook:415
+msgid ""
+ "<![CDATA[Collection blackKittens = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"where this.color = ?\")\n"
+ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
+ " .list()\n"
+ ");]]>"
+msgstr ""
+
+#: index.docbook:417
+msgid "The returned collection is considered a bag, and it's a copy of the given collection. The original collection is not modified (this is contrary to the implication of the name \"filter\", but consistent with expected behavior)."
+msgstr ""
+
+#: index.docbook:423
+msgid "Observe that filters do not require a <literal>from</literal> clause (though they may have one if required). Filters are not limited to returning the collection elements themselves."
+msgstr ""
+
+#: index.docbook:428
+msgid ""
+ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
+ " pk.getKittens(), \n"
+ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:430
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a huge collection:"
+msgstr ""
+
+#: index.docbook:435
+msgid ""
+ "<![CDATA[Collection tenKittens = session.createFilter(\n"
+ " mother.getKittens(), \"\")\n"
+ " .setFirstResult(0).setMaxResults(10)\n"
+ " .list();]]>"
+msgstr ""
+
+#: index.docbook:440
+msgid "Criteria queries"
+msgstr ""
+
+#: index.docbook:442
+msgid "HQL is extremely powerful but some developers prefer to build queries dynamically, using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr ""
+
+#: index.docbook:448
+msgid ""
+ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
+ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
+ "crit.setMaxResults(10);\n"
+ "List cats = crit.list();]]>"
+msgstr ""
+
+#: index.docbook:450
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\"/>."
+msgstr ""
+
+#: index.docbook:458
+msgid "Queries in native SQL"
+msgstr ""
+
+#: index.docbook:460
+msgid "You may express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate take care of the mapping from result sets to objects. Note that you may at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you chose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr ""
+
+#: index.docbook:468
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list();]]>"
+msgstr ""
+
+#: index.docbook:470
+msgid ""
+ "<![CDATA[List cats = session.createSQLQuery(\n"
+ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
+ " \"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... \" +\n"
+ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
+ " .addEntity(\"cat\", Cat.class)\n"
+ ".list()]]>"
+msgstr ""
+
+#: index.docbook:472
+msgid "SQL queries may contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\"/>."
+msgstr ""
+
+#: index.docbook:483
+msgid "Modifying persistent objects"
+msgstr ""
+
+#: index.docbook:485
+msgid "<emphasis>Transactional persistent instances</emphasis> (ie. objects loaded, saved, created or queried by the <literal>Session</literal>) may be manipulated by the application and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis> (discussed later in this chapter). There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. So the most straightforward way to update the state of an object is to <literal>load()</literal> it, and then manipulate it directly, while the <literal>Session</literal> is open:"
+msgstr ""
+
+#: index.docbook:496
+msgid ""
+ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );\n"
+ "cat.setName(\"PK\");\n"
+ "sess.flush(); // changes to cat are automatically detected and persisted]]>"
+msgstr ""
+
+#: index.docbook:498
+msgid "Sometimes this programming model is inefficient since it would require both an SQL <literal>SELECT</literal> (to load an object) and an SQL <literal>UPDATE</literal> (to persist its updated state) in the same session. Therefore Hibernate offers an alternate approach, using detached instances."
+msgstr ""
+
+#: index.docbook:506
+msgid "Note that Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you don't have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate may however provide special mass operation functions. See <xref linkend=\"batch\"/> for some possible batch operation tricks."
+msgstr ""
+
+#: index.docbook:521
+msgid "Modifying detached objects"
+msgstr ""
+
+#: index.docbook:523
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr ""
+
+#: index.docbook:530
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr ""
+
+#: index.docbook:536
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
+ "Cat potentialMate = new Cat();\n"
+ "firstSession.save(potentialMate);\n"
+ "\n"
+ "// in a higher layer of the application\n"
+ "cat.setMate(potentialMate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.update(cat); // update cat\n"
+ "secondSession.update(mate); // update mate]]>"
+msgstr ""
+
+#: index.docbook:538
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr ""
+
+#: index.docbook:544
+msgid "Use <literal>update()</literal> if you are sure that the session does not contain an already persistent instance with the same identifier, and <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that reattachment of your detached instances is the first operation that is executed."
+msgstr ""
+
+#: index.docbook:553
+msgid "The application should individually <literal>update()</literal> detached instances reachable from the given detached instance if and <emphasis>only</emphasis> if it wants their state also updated. This can be automated of course, using <emphasis>transitive persistence</emphasis>, see <xref linkend=\"objectstate-transitive\"/>."
+msgstr ""
+
+#: index.docbook:560
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified!"
+msgstr ""
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[//just reassociate:\n"
+ "sess.lock(fritz, LockMode.NONE);\n"
+ "//do a version check, then reassociate:\n"
+ "sess.lock(izi, LockMode.READ);\n"
+ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
+ "sess.lock(pk, LockMode.UPGRADE);]]>"
+msgstr ""
+
+#: index.docbook:567
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s, see the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr ""
+
+#: index.docbook:574
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\"/>."
+msgstr ""
+
+#: index.docbook:581
+msgid "Automatic state detection"
+msgstr ""
+
+#: index.docbook:583
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr ""
+
+#: index.docbook:590
+msgid ""
+ "<![CDATA[// in the first session\n"
+ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
+ "\n"
+ "// in a higher tier of the application\n"
+ "Cat mate = new Cat();\n"
+ "cat.setMate(mate);\n"
+ "\n"
+ "// later, in a new session\n"
+ "secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id)\n"
+ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)]]>"
+msgstr ""
+
+#: index.docbook:592
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr ""
+
+#: index.docbook:600
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr ""
+
+#: index.docbook:607
+msgid "the application loads an object in the first session"
+msgstr ""
+
+#: index.docbook:612
+msgid "the object is passed up to the UI tier"
+msgstr ""
+
+#: index.docbook:617
+msgid "some modifications are made to the object"
+msgstr ""
+
+#: index.docbook:622
+msgid "the object is passed back down to the business logic tier"
+msgstr ""
+
+#: index.docbook:627
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
+msgstr ""
+
+#: index.docbook:634
+msgid "<literal>saveOrUpdate()</literal> does the following:"
+msgstr ""
+
+#: index.docbook:640
+msgid "if the object is already persistent in this session, do nothing"
+msgstr ""
+
+#: index.docbook:645
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr ""
+
+#: index.docbook:651
+msgid "if the object has no identifier property, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:656
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:662
+msgid "if the object is versioned (by a <literal><version></literal> or <literal><timestamp></literal>), and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr ""
+
+#: index.docbook:670
+msgid "otherwise <literal>update()</literal> the object"
+msgstr ""
+
+#: index.docbook:676
+msgid "and <literal>merge()</literal> is very different:"
+msgstr ""
+
+#: index.docbook:682
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr ""
+
+#: index.docbook:689
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr ""
+
+#: index.docbook:695
+msgid "the persistent instance is returned"
+msgstr ""
+
+#: index.docbook:700
+msgid "the given instance does not become associated with the session, it remains detached"
+msgstr ""
+
+#: index.docbook:710
+msgid "Deleting persistent objects"
+msgstr ""
+
+#: index.docbook:712
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Of course, your application might still hold a reference to a deleted object. It's best to think of <literal>delete()</literal> as making a persistent instance transient."
+msgstr ""
+
+#: index.docbook:719
+msgid "<![CDATA[sess.delete(cat);]]>"
+msgstr ""
+
+#: index.docbook:721
+msgid "You may delete objects in any order you like, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr ""
+
+#: index.docbook:732
+msgid "Replicating object between two different datastores"
+msgstr ""
+
+#: index.docbook:734
+msgid "It is occasionally useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr ""
+
+#: index.docbook:740
+msgid ""
+ "<![CDATA[//retrieve a cat from one database\n"
+ "Session session1 = factory1.openSession();\n"
+ "Transaction tx1 = session1.beginTransaction();\n"
+ "Cat cat = session1.get(Cat.class, catId);\n"
+ "tx1.commit();\n"
+ "session1.close();\n"
+ "\n"
+ "//reconcile with a second database\n"
+ "Session session2 = factory2.openSession();\n"
+ "Transaction tx2 = session2.beginTransaction();\n"
+ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
+ "tx2.commit();\n"
+ "session2.close();]]>"
+msgstr ""
+
+#: index.docbook:742
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database."
+msgstr ""
+
+#: index.docbook:749
+msgid "<literal>ReplicationMode.IGNORE</literal> - ignore the object when there is an existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:755
+msgid "<literal>ReplicationMode.OVERWRITE</literal> - overwrite any existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:761
+msgid "<literal>ReplicationMode.EXCEPTION</literal> - throw an exception if there is an existing database row with the same identifier"
+msgstr ""
+
+#: index.docbook:767
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal> - overwrite the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr ""
+
+#: index.docbook:775
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr ""
+
+#: index.docbook:784
+msgid "Flushing the Session"
+msgstr ""
+
+#: index.docbook:786
+msgid "From time to time the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, <emphasis>flush</emphasis>, occurs by default at the following points"
+msgstr ""
+
+#: index.docbook:795
+msgid "before some query executions"
+msgstr ""
+
+#: index.docbook:800
+msgid "from <literal>org.hibernate.Transaction.commit()</literal>"
+msgstr ""
+
+#: index.docbook:805
+msgid "from <literal>Session.flush()</literal>"
+msgstr ""
+
+#: index.docbook:811
+msgid "The SQL statements are issued in the following order"
+msgstr ""
+
+#: index.docbook:817
+msgid "all entity insertions, in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr ""
+
+#: index.docbook:823
+msgid "all entity updates"
+msgstr ""
+
+#: index.docbook:828
+msgid "all collection deletions"
+msgstr ""
+
+#: index.docbook:833
+msgid "all collection element deletions, updates and insertions"
+msgstr ""
+
+#: index.docbook:838
+msgid "all collection insertions"
+msgstr ""
+
+#: index.docbook:843
+msgid "all entity deletions, in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr ""
+
+#: index.docbook:850
+msgid "(An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved.)"
+msgstr ""
+
+#: index.docbook:855
+msgid "Except when you explicity <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale data; nor will they return the wrong data."
+msgstr ""
+
+#: index.docbook:863
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time (and only when the Hibernate <literal>Transaction</literal> API is used), flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\"/>)."
+msgstr ""
+
+#: index.docbook:873
+msgid ""
+ "<![CDATA[sess = sf.openSession();\n"
+ "Transaction tx = sess.beginTransaction();\n"
+ "sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale state\n"
+ "\n"
+ "Cat izi = (Cat) sess.load(Cat.class, id);\n"
+ "izi.setName(iznizi);\n"
+ "\n"
+ "// might return stale data\n"
+ "sess.find(\"from Cat as cat left outer join cat.kittens kitten\");\n"
+ "\n"
+ "// change to izi is not flushed!\n"
+ "...\n"
+ "tx.commit(); // flush occurs\n"
+ "sess.close();]]>"
+msgstr ""
+
+#: index.docbook:875
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\"/>."
+msgstr ""
+
+#: index.docbook:884
+msgid "Transitive persistence"
+msgstr ""
+
+#: index.docbook:886
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr ""
+
+#: index.docbook:892
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved as well, when the parent is deleted, the children will be deleted, etc. This even works for operations such as the removal of a child from the collection; Hibernate will detect this and, since value-typed objects can't have shared references, delete the child from the database."
+msgstr ""
+
+#: index.docbook:903
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle, support shared references (so removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr ""
+
+#: index.docbook:912
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr ""
+
+#: index.docbook:921
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
+msgstr ""
+
+#: index.docbook:923
+msgid "Cascade styles my be combined:"
+msgstr ""
+
+#: index.docbook:927
+msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
+msgstr ""
+
+#: index.docbook:929
+msgid "You may even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr ""
+
+#: index.docbook:935
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr ""
+
+#: index.docbook:942
+msgid "Recommendations:"
+msgstr ""
+
+#: index.docbook:948
+msgid "It doesn't usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr ""
+
+#: index.docbook:956
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr ""
+
+#: index.docbook:963
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr ""
+
+#: index.docbook:971
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr ""
+
+#: index.docbook:977
+msgid "Futhermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr ""
+
+#: index.docbook:988
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr ""
+
+#: index.docbook:994
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr ""
+
+#: index.docbook:1000
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: index.docbook:1006
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr ""
+
+#: index.docbook:1012
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
+msgstr ""
+
+#: index.docbook:1017
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr ""
+
+#: index.docbook:1026
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-upate</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:1038
+msgid "Using metadata"
+msgstr ""
+
+#: index.docbook:1040
+msgid "Hibernate requires a very rich meta-level model of all entity and value types. From time to time, this model is very useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which should not (eg. immutable value types and, possibly, associated entities)."
+msgstr ""
+
+#: index.docbook:1047
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces may be obtained from the <literal>SessionFactory</literal>."
+msgstr ""
+
+#: index.docbook:1054
+msgid ""
+ "<![CDATA[Cat fritz = ......;\n"
+ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
+ "\n"
+ "Object[] propertyValues = catMeta.getPropertyValues(fritz);\n"
+ "String[] propertyNames = catMeta.getPropertyNames();\n"
+ "Type[] propertyTypes = catMeta.getPropertyTypes();\n"
+ "\n"
+ "// get a Map of all properties which are not collections or associations\n"
+ "Map namedValues = new HashMap();\n"
+ "for ( int i=0; i<propertyNames.length; i++ ) {\n"
+ " if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {\n"
+ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/toolset_guide.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/toolset_guide.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/toolset_guide.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,744 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Toolset Guide"
+msgstr "工具箱指å—"
+
+#: index.docbook:7
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, as well as Ant tasks."
+msgstr "å¯ä»¥é€šè¿‡ä¸€ç³»åˆ—Eclipseæ’件ã€å‘½ä»¤è¡Œå·¥å…·å’ŒAnt任务æ¥è¿›è¡Œä¸ŽHibernateå…³è”的转æ¢ã€‚"
+
+#: index.docbook:12
+msgid "The <emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "除了Ant任务外，当å‰çš„<emphasis>Hibernate Tools</emphasis>也包å«äº†Eclipse IDEçš„æ’件，用于与现å˜æ•°æ®åº“的逆å‘工程。"
+
+#: index.docbook:18
+msgid "<emphasis>Mapping Editor:</emphasis> An editor for Hibernate XML mapping files, supporting auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it much more versatile than a normal XML editor."
+msgstr "<emphasis>Mapping Editor:</emphasis> Hibernate XMLæ˜ å°„æ–‡ä»¶çš„ç¼–è¾‘å™¨ï¼Œæ”¯æŒè‡ªåŠ¨å®Œæˆå’Œè¯æ³•é«˜äº®ã€‚它也支æŒå¯¹ç±»å和属性/å—段åçš„è¯ä¹‰è‡ªåŠ¨å®Œæˆï¼Œæ¯”通常的XML编辑器方便得多。"
+
+#: index.docbook:23
+msgid "<emphasis>Console:</emphasis> The console is a new view in Eclipse. In addition to a tree overview of your console configurations, you also get an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>Console:</emphasis> Console是Eclipseçš„ä¸€ä¸ªæ–°è§†å›¾ã€‚é™¤äº†å¯¹ä½ çš„consoleé…ç½®çš„æ ‘çŠ¶æ¦‚è§ˆï¼Œä½ è¿˜å¯ä»¥èŽ·å¾—å¯¹ä½ æŒä¹…化类åŠå…¶å…³è”的交互å¼è§†å›¾ã€‚Consoleå…è®¸ä½ å¯¹æ•°æ®åº“执行HQL查询，并直接在Eclipseä¸æµè§ˆç»“果。"
+
+#: index.docbook:30
+msgid "<emphasis>Development Wizards:</emphasis> Several wizards are provided with the Hibernate Eclipse tools; you can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or you may even completely reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>Development Wizards:</emphasis> 在Hibernate Eclipse toolsä¸è¿˜æä¾›äº†å‡ ä¸ªå‘å¯¼ï¼›ä½ å¯ä»¥ç”¨å‘导快速生æˆHibernate é…置文件（cfg.xmlï¼‰ï¼Œä½ ç”šè‡³è¿˜å¯ä»¥åŒçŽ°å˜çš„æ•°æ®åº“schemaä¸åå‘工程出POJOæºä»£ç 与Hibernate æ˜ å°„æ–‡ä»¶ã€‚åå‘工程支æŒå¯å®šåˆ¶çš„模版。"
+
+#: index.docbook:38
+msgid "Ant Tasks:"
+msgstr "Ant Tasks:"
+
+#: index.docbook:43
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package and it's documentation for more information."
+msgstr "è¦å¾—到更多信æ¯ï¼Œè¯·æŸ¥é˜… <emphasis>Hibernate Tools</emphasis> 包åŠå…¶æ–‡æ¡£ã€‚"
+
+#: index.docbook:48
+msgid "However, the Hibernate main package comes bundled with an integrated tool (it can even be used from \"inside\" Hibernate on-the-fly): <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>."
+msgstr "åŒæ—¶ï¼ŒHibernate主å‘行包还附带了一个集æˆçš„工具（它甚至å¯ä»¥åœ¨Hibernate“内部â€å¿«é€Ÿè¿è¡Œï¼‰<emphasis>SchemaExport</emphasis> ，也就是 <literal>hbm2ddl</literal>。"
+
+#: index.docbook:55
+msgid "Automatic schema generation"
+msgstr "Schema自动生æˆï¼ˆAutomatic schema generation）"
+
+#: index.docbook:57
+msgid "DDL may be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints (primary and foreign keys) for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "å¯ä»¥ä»Žä½ çš„æ˜ å°„æ–‡ä»¶ä½¿ç”¨ä¸€ä¸ªHibernate工具生æˆDDL。 生æˆçš„schema包å«æœ‰å¯¹å®žä½“和集åˆç±»è¡¨çš„完整性引用约æŸï¼ˆä¸»é”®å’Œå¤–键）。涉åŠåˆ°çš„æ ‡ç¤ºç¬¦ç”Ÿæˆå™¨æ‰€éœ€çš„表和sequence也会åŒæ—¶ç”Ÿæˆã€‚"
+
+#: index.docbook:64
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor specific."
+msgstr "åœ¨ä½¿ç”¨è¿™ä¸ªå·¥å…·çš„æ—¶å€™ï¼Œä½ <emphasis>å¿…é¡»</emphasis> 通过<literal>hibernate.dialet</literal>属性指定一个SQL<literal>方言(Dialet)</literal>ï¼Œå› ä¸ºDDL是与供应商高度相关的。"
+
+#: index.docbook:70
+msgid "First, customize your mapping files to improve the generated schema."
+msgstr "首先，è¦å®šåˆ¶ä½ çš„æ˜ å°„æ–‡ä»¶ï¼Œæ¥æ”¹å–„生æˆçš„schema。"
+
+#: index.docbook:75
+msgid "Customizing the schema"
+msgstr "对schema定制化(Customizing the schema)"
+
+#: index.docbook:77
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You may set the length, precision and scale of a column with this attribute."
+msgstr "很多Hibernateæ˜ å°„å…ƒç´ å®šä¹‰äº†å¯é€‰çš„<literal>length</literal>ã€<literal>precision</literal> 或者 <literal>scale</literal>å±žæ€§ã€‚ä½ å¯ä»¥é€šè¿‡è¿™ä¸ªå±žæ€§è®¾ç½®å—段的长度ã€ç²¾åº¦ã€å°æ•°ç‚¹ä½æ•°ã€‚"
+
+#: index.docbook:84
+msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+msgstr "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>"
+
+#: index.docbook:85
+msgid "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+msgstr "<![CDATA[<property name=\"balance\" precision=\"12\" scale=\"2\"/>]]>"
+
+#: index.docbook:87
+msgid "Some tags also accept a <literal>not-null</literal> attribute (for generating a <literal>NOT NULL</literal> constraint on table columns) and a <literal>unique</literal> attribute (for generating <literal>UNIQUE</literal> constraint on table columns)."
+msgstr "有些tag还接å—<literal>not-null</literal>属性（用æ¥åœ¨è¡¨å—段上生æˆ<literal>NOT NULL</literal>约æŸï¼‰å’Œ<literal>unique</literal>属性（用æ¥åœ¨è¡¨å—段上生æˆ<literal>UNIQUE</literal>约æŸï¼‰ã€‚"
+
+#: index.docbook:93
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" not-null=\"true\"/>]]>"
+
+#: index.docbook:95
+msgid "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+msgstr "<![CDATA[<element column=\"serialNumber\" type=\"long\" not-null=\"true\" unique=\"true\"/>]]>"
+
+#: index.docbook:97
+msgid "A <literal>unique-key</literal> attribute may be used to group columns in a single unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL, only to group the columns in the mapping file."
+msgstr "<literal>unique-key</literal>属性å¯ä»¥å¯¹æˆç»„çš„å—段指定一个唯一键约æŸ(unique key constraint)。目å‰ï¼Œ<literal>unique-key</literal>属性指定的值在生æˆDDLæ—¶<emphasis>并ä¸ä¼š</emphasis>被当作这个约æŸçš„åå—，它们åªæ˜¯åœ¨ç”¨æ¥åœ¨æ˜ 射文件内部用作区分的。"
+
+#: index.docbook:105
+msgid ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+msgstr ""
+ "<![CDATA[<many-to-one name=\"org\" column=\"orgId\" unique-key=\"OrgEmployeeId\"/>\n"
+ "<property name=\"employeeId\" unique-key=\"OrgEmployee\"/>]]>"
+
+#: index.docbook:107
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns may be grouped into the same index, simply by specifying the same index name."
+msgstr "<literal>index</literal>属性会用对应的å—段（一个或多个）生æˆä¸€ä¸ªindex,它指出了这个indexçš„åå—。如果多个å—段对应的indexåå—相åŒï¼Œå°±ä¼šç”ŸæˆåŒ…å«è¿™äº›å—段的index。"
+
+#: index.docbook:113
+msgid ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"lastName\" index=\"CustName\"/>\n"
+ "<property name=\"firstName\" index=\"CustName\"/>]]>"
+
+#: index.docbook:115
+msgid "A <literal>foreign-key</literal> attribute may be used to override the name of any generated foreign key constraint."
+msgstr "<literal>foreign-key</literal>属性å¯ä»¥ç”¨æ¥è¦†ç›–任何生æˆçš„外键约æŸçš„åå—。"
+
+#: index.docbook:120
+msgid "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+msgstr "<![CDATA[<many-to-one name=\"bar\" column=\"barId\" foreign-key=\"FKFooBar\"/>]]>"
+
+#: index.docbook:122
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "å¾ˆå¤šæ˜ å°„å…ƒç´ è¿˜æŽ¥å—<literal><column></literal>åå…ƒç´ ã€‚è¿™åœ¨å®šä¹‰è·¨è¶Šå¤šå—段的类型时特别有用。"
+
+#: index.docbook:127
+msgid ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"name\" type=\"my.customtypes.Name\"/>\n"
+ " <column name=\"last\" not-null=\"true\" index=\"bar_idx\" length=\"30\"/>\n"
+ " <column name=\"first\" not-null=\"true\" index=\"bar_idx\" length=\"20\"/>\n"
+ " <column name=\"initial\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:129
+msgid "The <literal>default</literal> attribute lets you specify a default value for a column (you should assign the same value to the mapped property before saving a new instance of the mapped class)."
+msgstr "<literal>default</literal>属性为å—段指定一个默认值 (在ä¿å˜è¢«æ˜ 射的类的新实例之å‰ï¼Œä½ 应该将åŒæ ·çš„值赋于对应的属性)。"
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"credits\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"credits\" default=\"10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:137
+msgid ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<version name=\"version\" type=\"integer\" insert=\"false\">\n"
+ " <column name=\"version\" default=\"0\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:139
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "<literal>sql-type</literal>属性å…许用户覆盖默认的Hibernate类型到SQLæ•°æ®ç±»åž‹çš„æ˜ å°„ã€‚"
+
+#: index.docbook:144
+msgid ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\" type=\"float\">\n"
+ " <column name=\"balance\" sql-type=\"decimal(13,3)\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:146
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
+msgstr "<literal>check</literal>属性å…许用户指定一个约æŸæ£€æŸ¥ã€‚"
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"foo\" type=\"integer\">\n"
+ " <column name=\"foo\" check=\"foo > 10\"/>\n"
+ "</property>]]>"
+
+#: index.docbook:152
+msgid ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Foo\" table=\"foos\" check=\"bar < 100.0\">\n"
+ " ...\n"
+ " <property name=\"bar\" type=\"float\"/>\n"
+ "</class>]]>"
+
+#: index.docbook:156
+msgid "Summary"
+msgstr "Summary"
+
+#: index.docbook:163
+msgid "Attribute"
+msgstr "属性(Attribute)"
+
+#: index.docbook:164
+msgid "Values"
+msgstr "值（Values）"
+
+#: index.docbook:165
+msgid "Interpretation"
+msgstr "解释（Interpretation）"
+
+#: index.docbook:170
+msgid "length"
+msgstr "length"
+
+#: index.docbook:171, index.docbook:176, index.docbook:181
+msgid "number"
+msgstr "<entry>æ•°å—</entry>"
+
+#: index.docbook:172
+msgid "column length"
+msgstr "å—段长度"
+
+#: index.docbook:175
+msgid "precision"
+msgstr "precision"
+
+#: index.docbook:177
+msgid "column decimal precision"
+msgstr "精度(decimal precision)"
+
+#: index.docbook:180
+msgid "scale"
+msgstr "scale"
+
+#: index.docbook:182
+msgid "column decimal scale"
+msgstr "å°æ•°ç‚¹ä½æ•°(decimal scale)"
+
+#: index.docbook:185
+msgid "not-null"
+msgstr "not-null"
+
+#: index.docbook:186, index.docbook:191
+msgid "true|false"
+msgstr "true|false"
+
+#: index.docbook:187
+msgid "specfies that the column should be non-nullable"
+msgstr "指明å—段是å¦åº”该是éžç©ºçš„"
+
+#: index.docbook:190
+msgid "unique"
+msgstr "unique"
+
+#: index.docbook:192
+msgid "specifies that the column should have a unique constraint"
+msgstr "指明是å¦è¯¥å—段具有惟一约æŸ"
+
+#: index.docbook:195
+msgid "index"
+msgstr "index"
+
+#: index.docbook:196
+msgid "index_name"
+msgstr "index_name"
+
+#: index.docbook:197
+msgid "specifies the name of a (multi-column) index"
+msgstr "指明一个（多å—段）的索引(index)çš„åå—"
+
+#: index.docbook:200
+msgid "unique-key"
+msgstr "unique-key"
+
+#: index.docbook:201
+msgid "unique_key_name"
+msgstr "unique_key_name"
+
+#: index.docbook:202
+msgid "specifies the name of a multi-column unique constraint"
+msgstr "指明多å—段惟一约æŸçš„åå—（å‚è§ä¸Šé¢çš„说明）"
+
+#: index.docbook:205
+msgid "foreign-key"
+msgstr "foreign-key"
+
+#: index.docbook:206
+msgid "foreign_key_name"
+msgstr "foreign_key_name"
+
+#: index.docbook:207
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>. 指明一个外键的åå—，它是为关è”生æˆçš„，或者<literal><one-to-one></literal>，<literal><many-to-one></literal>, <literal><key></literal>, 或者<literal><many-to-many></literal>æ˜ å°„å…ƒç´ ã€‚æ³¨æ„<literal>inverse=\"true\"</literal>在<literal>SchemaExport</literal>时会被忽略。"
+
+#: index.docbook:217
+msgid "sql-type"
+msgstr "sql-type"
+
+#: index.docbook:218
+msgid "SQL column type"
+msgstr "SQL å—段类型"
+
+#: index.docbook:219
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
+msgstr "覆盖默认的å—段类型(åªèƒ½ç”¨äºŽ<literal><column></literal>属性）"
+
+#: index.docbook:225
+msgid "default"
+msgstr "default"
+
+#: index.docbook:226, index.docbook:233
+msgid "SQL expression"
+msgstr "SQL表达å¼"
+
+#: index.docbook:227
+msgid "specify a default value for the column"
+msgstr "为å—段指定默认值"
+
+#: index.docbook:232
+msgid "check"
+msgstr "check"
+
+#: index.docbook:234
+msgid "create an SQL check constraint on either column or table"
+msgstr "对å—æ®µæˆ–è¡¨åŠ å…¥SQL约æŸæ£€æŸ¥"
+
+#: index.docbook:242
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr "<literal><comment></literal>å…ƒç´ å¯ä»¥è®©ä½ 在生æˆçš„schemaä¸åŠ 入注释。"
+
+#: index.docbook:247
+msgid ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+msgstr ""
+ "<![CDATA[<class name=\"Customer\" table=\"CurCust\">\n"
+ " <comment>Current customers only</comment>\n"
+ " ...\n"
+ "</class>]]>"
+
+#: index.docbook:249
+msgid ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+msgstr ""
+ "<![CDATA[<property name=\"balance\">\n"
+ " <column name=\"bal\">\n"
+ " <comment>Balance in USD</comment>\n"
+ " </column>\n"
+ "</property>]]>"
+
+#: index.docbook:251
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL (where supported)."
+msgstr "结果是在生æˆçš„DDLä¸åŒ…å«<literal>comment on table</literal> 或者 <literal>comment on column</literal>è¯å¥(å‡è‹¥æ”¯æŒçš„è¯)。"
+
+#: index.docbook:260
+msgid "Running the tool"
+msgstr "è¿è¡Œè¯¥å·¥å…·"
+
+#: index.docbook:262
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "<literal>SchemaExport</literal>工具把DDLè„šæœ¬å†™åˆ°æ ‡å‡†è¾“å‡ºï¼ŒåŒæ—¶/或者执行DDLè¯å¥ã€‚"
+
+#: index.docbook:267
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:273
+msgid "<literal>SchemaExport</literal> Command Line Options"
+msgstr "<literal>SchemaExport</literal>命令行选项"
+
+#: index.docbook:279, index.docbook:429, index.docbook:498
+msgid "Option"
+msgstr "<entry>选项</entry>"
+
+#: index.docbook:280, index.docbook:367, index.docbook:430, index.docbook:499
+msgid "Description"
+msgstr "<entry>说明</entry>"
+
+#: index.docbook:285, index.docbook:435
+msgid "--quiet"
+msgstr "--quiet"
+
+#: index.docbook:286, index.docbook:436
+msgid "don't output the script to stdout"
+msgstr "ä¸è¦æŠŠè„šæœ¬è¾“出到stdout"
+
+#: index.docbook:289
+msgid "--drop"
+msgstr "--drop"
+
+#: index.docbook:290
+msgid "only drop the tables"
+msgstr "åªè¿›è¡Œdrop tablesçš„æ¥éª¤"
+
+#: index.docbook:293
+msgid "--create"
+msgstr "--create"
+
+#: index.docbook:294
+msgid "only create the tables"
+msgstr "åªåˆ›å»ºè¡¨"
+
+#: index.docbook:297, index.docbook:439
+msgid "--text"
+msgstr "--text"
+
+#: index.docbook:298
+msgid "don't export to the database"
+msgstr "ä¸æ‰§è¡Œåœ¨æ•°æ®åº“ä¸è¿è¡Œçš„æ¥éª¤"
+
+#: index.docbook:301
+msgid "--output=my_schema.ddl"
+msgstr "--output=my_schema.ddl"
+
+#: index.docbook:302
+msgid "output the ddl script to a file"
+msgstr "把输出的ddl脚本输出到一个文件"
+
+#: index.docbook:305, index.docbook:443, index.docbook:504
+msgid "--naming=eg.MyNamingStrategy"
+msgstr "--naming=eg.MyNamingStrategy"
+
+#: index.docbook:306, index.docbook:444, index.docbook:505
+msgid "select a <literal>NamingStrategy</literal>"
+msgstr "选择一个命åç–ç•¥(<literal>NamingStrategy</literal>)"
+
+#: index.docbook:309, index.docbook:451, index.docbook:512
+msgid "--config=hibernate.cfg.xml"
+msgstr "--config=hibernate.cfg.xml"
+
+#: index.docbook:310
+msgid "read Hibernate configuration from an XML file"
+msgstr "从XML文件读入Hibernateé…ç½®"
+
+#: index.docbook:313, index.docbook:447, index.docbook:508
+msgid "--properties=hibernate.properties"
+msgstr "--properties=hibernate.properties"
+
+#: index.docbook:314, index.docbook:448, index.docbook:509
+msgid "read database properties from a file"
+msgstr "从文件读入数æ®åº“属性"
+
+#: index.docbook:317
+msgid "--format"
+msgstr "--format"
+
+#: index.docbook:318
+msgid "format the generated SQL nicely in the script"
+msgstr "把脚本ä¸çš„SQLè¯å¥å¯¹é½å’Œç¾ŽåŒ–"
+
+#: index.docbook:321
+msgid "--delimiter=;"
+msgstr "--delimiter=;"
+
+#: index.docbook:322
+msgid "set an end of line delimiter for the script"
+msgstr "为脚本设置行结æŸç¬¦"
+
+#: index.docbook:328
+msgid "You may even embed <literal>SchemaExport</literal> in your application:"
+msgstr "ä½ ç”šè‡³å¯ä»¥åœ¨ä½ 的应用程åºä¸åµŒå…¥<literal>SchemaExport</literal>工具:"
+
+#: index.docbook:332
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaExport(cfg).create(false, true);]]>"
+
+#: index.docbook:337
+msgid "Properties"
+msgstr "属性(Properties)"
+
+#: index.docbook:339
+msgid "Database properties may be specified"
+msgstr "å¯ä»¥é€šè¿‡å¦‚下方å¼æŒ‡å®šæ•°æ®åº“属性:"
+
+#: index.docbook:345
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "通过<literal>-D</literal><emphasis><property></emphasis>系统å‚æ•°"
+
+#: index.docbook:348
+msgid "in <literal>hibernate.properties</literal>"
+msgstr "在<literal>hibernate.properties</literal>文件ä¸"
+
+#: index.docbook:351
+msgid "in a named properties file with <literal>--properties</literal>"
+msgstr "ä½äºŽä¸€ä¸ªå…¶å®ƒåå—çš„properties文件ä¸,然åŽç”¨ <literal>--properties</literal>å‚数指定"
+
+#: index.docbook:355
+msgid "The needed properties are:"
+msgstr "所需的å‚数包括:"
+
+#: index.docbook:360
+msgid "SchemaExport Connection Properties"
+msgstr "SchemaExport 连接属性"
+
+#: index.docbook:366
+msgid "Property Name"
+msgstr "<entry>属性å</entry>"
+
+#: index.docbook:372
+msgid "hibernate.connection.driver_class"
+msgstr "hibernate.connection.driver_class"
+
+#: index.docbook:373
+msgid "jdbc driver class"
+msgstr "jdbc driver class"
+
+#: index.docbook:376
+msgid "hibernate.connection.url"
+msgstr "hibernate.connection.url"
+
+#: index.docbook:377
+msgid "jdbc url"
+msgstr "jdbc url"
+
+#: index.docbook:380
+msgid "hibernate.connection.username"
+msgstr "hibernate.connection.username"
+
+#: index.docbook:381
+msgid "database user"
+msgstr "database user"
+
+#: index.docbook:384
+msgid "hibernate.connection.password"
+msgstr "hibernate.connection.password"
+
+#: index.docbook:385
+msgid "user password"
+msgstr "user password"
+
+#: index.docbook:388
+msgid "hibernate.dialect"
+msgstr "hibernate.dialect"
+
+#: index.docbook:389
+msgid "dialect"
+msgstr "方言(dialect)"
+
+#: index.docbook:398
+msgid "Using Ant"
+msgstr "使用Ant(Using Ant)"
+
+#: index.docbook:400
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgstr "ä½ å¯ä»¥åœ¨ä½ çš„Ant build脚本ä¸è°ƒç”¨<literal>SchemaExport</literal>:"
+
+#: index.docbook:404
+msgid ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemaexport\">\n"
+ " <taskdef name=\"schemaexport\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaExportTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaexport\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\"\n"
+ " text=\"no\"\n"
+ " drop=\"no\"\n"
+ " delimiter=\";\"\n"
+ " output=\"schema-export.sql\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaexport>\n"
+ "</target>]]>"
+
+#: index.docbook:409
+msgid "Incremental schema updates"
+msgstr "对schema的增é‡æ›´æ–°(Incremental schema updates)"
+
+#: index.docbook:411
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. Note that <literal>SchemaUpdate</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers."
+msgstr "<literal>SchemaUpdate</literal>工具对已å˜åœ¨çš„schema采用\"增é‡\"æ–¹å¼è¿›è¡Œæ›´æ–°ã€‚注æ„<literal>SchemaUpdate</literal>严é‡ä¾èµ–于JDBC metadata API,所以它并éžå¯¹æ‰€æœ‰JDBC驱动都有效。"
+
+#: index.docbook:417
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:423
+msgid "<literal>SchemaUpdate</literal> Command Line Options"
+msgstr "<literal>SchemaUpdate</literal>命令行选项"
+
+#: index.docbook:440
+msgid "don't export the script to the database"
+msgstr "ä¸æŠŠè„šæœ¬è¾“出到数æ®åº“"
+
+#: index.docbook:452, index.docbook:513
+msgid "specify a <literal>.cfg.xml</literal> file"
+msgstr "指定一个 <literal>.cfg.xml</literal>文件"
+
+#: index.docbook:458
+msgid "You may embed <literal>SchemaUpdate</literal> in your application:"
+msgstr "ä½ å¯ä»¥åœ¨ä½ 的应用程åºä¸åµŒå…¥<literal>SchemaUpdate</literal>工具:"
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaUpdate(cfg).execute(false);]]>"
+
+#: index.docbook:467
+msgid "Using Ant for incremental schema updates"
+msgstr "用Antæ¥å¢žé‡æ›´æ–°schema(Using Ant for incremental schema updates)"
+
+#: index.docbook:469
+msgid "You can call <literal>SchemaUpdate</literal> from the Ant script:"
+msgstr "ä½ å¯ä»¥åœ¨Ant脚本ä¸è°ƒç”¨<literal>SchemaUpdate</literal>："
+
+#: index.docbook:473
+msgid ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemaupdate\">\n"
+ " <taskdef name=\"schemaupdate\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaUpdateTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemaupdate\n"
+ " properties=\"hibernate.properties\"\n"
+ " quiet=\"no\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemaupdate>\n"
+ "</target>]]>"
+
+#: index.docbook:478
+msgid "Schema validation"
+msgstr "Schema æ ¡éªŒ"
+
+#: index.docbook:480
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. Note that <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API, so it will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr "<literal>SchemaValidator</literal>工具会比较数æ®åº“现状是å¦ä¸Žæ˜ 射文档“匹é…â€ã€‚注æ„，<literal>SchemaValidator</literal> 严é‡ä¾èµ–于JDBCçš„metadata APIï¼Œå› æ¤ä¸æ˜¯å¯¹æ‰€æœ‰çš„JDBC驱动都适用。这一工具在测试的时候特别有用。"
+
+#: index.docbook:486
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+
+#: index.docbook:492
+msgid "<literal>SchemaValidator</literal> Command Line Options"
+msgstr "<literal>SchemaValidator</literal>命令行å‚æ•°"
+
+#: index.docbook:519
+msgid "You may embed <literal>SchemaValidator</literal> in your application:"
+msgstr "ä½ å¯ä»¥åœ¨ä½ 的应用程åºä¸åµŒå…¥<literal>SchemaValidator</literal>："
+
+#: index.docbook:523
+msgid ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+msgstr ""
+ "<![CDATA[Configuration cfg = ....;\n"
+ "new SchemaValidator(cfg).validate();]]>"
+
+#: index.docbook:528
+msgid "Using Ant for schema validation"
+msgstr "使用Ant进行schemaæ ¡éªŒ"
+
+#: index.docbook:530
+msgid "You can call <literal>SchemaValidator</literal> from the Ant script:"
+msgstr "ä½ å¯ä»¥åœ¨Ant脚本ä¸è°ƒç”¨<literal>SchemaValidator</literal>:"
+
+#: index.docbook:534
+msgid ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+msgstr ""
+ "<![CDATA[<target name=\"schemavalidate\">\n"
+ " <taskdef name=\"schemavalidator\"\n"
+ " classname=\"org.hibernate.tool.hbm2ddl.SchemaValidatorTask\"\n"
+ " classpathref=\"class.path\"/>\n"
+ " \n"
+ " <schemavalidator\n"
+ " properties=\"hibernate.properties\">\n"
+ " <fileset dir=\"src\">\n"
+ " <include name=\"**/*.hbm.xml\"/>\n"
+ " </fileset>\n"
+ " </schemavalidator>\n"
+ "</target>]]>"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/transactions.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/transactions.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/transactions.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,673 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "Transactions And Concurrency"
+msgstr ""
+
+#: index.docbook:7
+msgid "The most important point about Hibernate and concurrency control is that it is very easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. We highly recommend you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr ""
+
+#: index.docbook:14
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Note that thanks to the <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values)."
+msgstr ""
+
+#: index.docbook:22
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers a (minor) API for pessimistic locking of rows, using the <literal>SELECT FOR UPDATE</literal> syntax. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:29
+msgid "We start the discussion of concurrency control in Hibernate with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr ""
+
+#: index.docbook:36
+msgid "Session and transaction scopes"
+msgstr ""
+
+#: index.docbook:38
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr ""
+
+#: index.docbook:44
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal> (or a <literal>Datasource</literal>) unless it is needed, hence consume no resources until used."
+msgstr ""
+
+#: index.docbook:52
+msgid "To complete this picture you also have to think about database transactions. A database transaction has to be as short as possible, to reduce lock contention in the database. Long database transactions will prevent your application from scaling to highly concurrent load. Hence, it is almost never good design to hold a database transaction open during user think time, until the unit of work is complete."
+msgstr ""
+
+#: index.docbook:61
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries?"
+msgstr ""
+
+#: index.docbook:69
+msgid "Unit of work"
+msgstr ""
+
+#: index.docbook:71
+msgid "First, don't use the <emphasis>session-per-operation</emphasis> antipattern, that is, don't open and close a <literal>Session</literal> for every simple database call in a single thread! Of course, the same is true for database transactions. Database calls in an application are made using a planned sequence, they are grouped into atomic units of work. (Note that this also means that auto-commit after every single SQL statement is useless in an application, this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to do so, auto-commit mode immediately.) Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data. As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible."
+msgstr ""
+
+#: index.docbook:87
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is send to the server (where the Hibernate persistence layer runs), a new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. Once the work has been completed (and the response for the client has been prepared), the session is flushed and closed. You would also use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr ""
+
+#: index.docbook:99
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. All you have to do is start a transaction when a server request has to be processed, and end the transaction before the response is send to the client. You can do this in any way you like, common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you decide to use programmatic transaction demarcation, prefer the Hibernate <literal>Transaction</literal> API shown later in this chapter, for ease of use and code portability."
+msgstr ""
+
+#: index.docbook:112
+msgid "Your application code can access a \"current session\" to process the request by simply calling <literal>sessionFactory.getCurrentSession()</literal> anywhere and as often as needed. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\"/>."
+msgstr ""
+
+#: index.docbook:120
+msgid "Sometimes it is convenient to extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering is complete is easy to do if you implement your own interceptor. However, it is not easily doable if you rely on EJBs with container-managed transactions, as a transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples around this <emphasis>Open Session in View</emphasis> pattern."
+msgstr ""
+
+#: index.docbook:135
+msgid "Long conversations"
+msgstr ""
+
+#: index.docbook:137
+msgid "The session-per-request pattern is not the only useful concept you can use to design units of work. Many business processes require a whole series of interactions with the user interleaved with database accesses. In web and enterprise applications it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr ""
+
+#: index.docbook:147
+msgid "The first screen of a dialog opens, the data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr ""
+
+#: index.docbook:154
+msgid "The user clicks \"Save\" after 5 minutes and expects his modifications to be made persistent; he also expects that he was the only person editing this information and that no conflicting modification can occur."
+msgstr ""
+
+#: index.docbook:162
+msgid "We call this unit of work, from the point of view of the user, a long running <emphasis>conversation</emphasis> (or <emphasis>application transaction</emphasis>). There are many ways how you can implement this in your application."
+msgstr ""
+
+#: index.docbook:168
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification, and to guarantee isolation and atomicity. This is of course an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr ""
+
+#: index.docbook:176
+msgid "Clearly, we have to use several database transactions to implement the converastion. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data, all others simply read data (e.g. in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you use Hibernate's features:"
+msgstr ""
+
+#: index.docbook:189
+msgid "<emphasis>Automatic Versioning</emphasis> - Hibernate can do automatic optimistic concurrency control for you, it can automatically detect if a concurrent modification occured during user think time. Usually we only check at the end of the conversation."
+msgstr ""
+
+#: index.docbook:197
+msgid "<emphasis>Detached Objects</emphasis> - If you decide to use the already discussed <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications, the pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr ""
+
+#: index.docbook:207
+msgid "<emphasis>Extended (or Long) Session</emphasis> - The Hibernate <literal>Session</literal> may be disconnected from the underlying JDBC connection after the database transaction has been committed, and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> is usually not allowed to be flushed automatically, but explicitely."
+msgstr ""
+
+#: index.docbook:220
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages, we discuss them later in this chapter in the context of optimistic concurrency control."
+msgstr ""
+
+#: index.docbook:229
+msgid "Considering object identity"
+msgstr ""
+
+#: index.docbook:231
+msgid "An application may concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. Hence there are two different notions of identity:"
+msgstr ""
+
+#: index.docbook:240
+msgid "Database Identity"
+msgstr ""
+
+#: index.docbook:243
+msgid "foo.getId().equals( bar.getId() )"
+msgstr ""
+
+#: index.docbook:248
+msgid "JVM Identity"
+msgstr ""
+
+#: index.docbook:251
+msgid "foo==bar"
+msgstr ""
+
+#: index.docbook:257
+msgid "Then for objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e. in the scope of a <literal>Session</literal>) the two notions are equivalent, and JVM identity for database identity is guaranteed by Hibernate. However, while the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using (automatic versioning) at flush/commit time, using an optimistic approach."
+msgstr ""
+
+#: index.docbook:266
+msgid "This approach leaves Hibernate and the database to worry about concurrency; it also provides the best scalability, since guaranteeing identity in single-threaded units of work only doesn't need expensive locking or other means of synchronization. The application never needs to synchronize on any business object, as long as it sticks to a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application may safely use <literal>==</literal> to compare objects."
+msgstr ""
+
+#: index.docbook:275
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal>, might see unexpected results. This might occur even in some unexpected places, for example, if you put two detached instances into the same <literal>Set</literal>. Both might have the same database identity (i.e. they represent the same row), but JVM identity is by definition not guaranteed for instances in detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement his own notion of object equality. There is one caveat: Never use the database identifier to implement equality, use a business key, a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode breaks the contract of t!
he <literal>Set</literal>. Attributes for business keys don't have to be as stable as database primary keys, you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Also note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr ""
+
+#: index.docbook:296
+msgid "Common issues"
+msgstr ""
+
+#: index.docbook:298
+msgid "Never use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (of course, there are rare exceptions to this rule). Note that some of the following issues might also appear with the recommended patterns, make sure you understand the implications before making a design decision:"
+msgstr ""
+
+#: index.docbook:307
+msgid "A <literal>Session</literal> is not thread-safe. Things which are supposed to work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance would be shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (discussed later), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough may use the same <literal>Session</literal> in two concurrently running threads."
+msgstr ""
+
+#: index.docbook:318
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (discussed later in more detail). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction doesn't put your business objects back into the state they were at the start of the transaction. This means the database state and the business objects do get out of sync. Usually this is not a problem, because exceptions are not recoverable and you have to start over after rollback anyway."
+msgstr ""
+
+#: index.docbook:330
+msgid "The <literal>Session</literal> caches every object that is in persistent state (watched and checked for dirty state by Hibernate). This means it grows endlessly until you get an OutOfMemoryException, if you keep it open for a long time or simply load too much data. One solution for this is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you most likely should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\"/>. Keeping a <literal>Session</literal> open for the duration of a user session also means a high probability of stale data."
+msgstr ""
+
+#: index.docbook:348
+msgid "Database transaction demarcation"
+msgstr ""
+
+#: index.docbook:350
+msgid "Datatabase (or system) transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr ""
+
+#: index.docbook:360
+msgid "A Hibernate application can run in non-managed (i.e. standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries, in other words, begin, commit, or rollback database transactions himself. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively in deployment descriptors of EJB session beans, for example. Programmatic transaction demarcation is then no longer necessary."
+msgstr ""
+
+#: index.docbook:370
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases you'd use programmatic transaction demaracation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr ""
+
+#: index.docbook:379
+msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:"
+msgstr ""
+
+#: index.docbook:385
+msgid "flush the session"
+msgstr ""
+
+#: index.docbook:390
+msgid "commit the transaction"
+msgstr ""
+
+#: index.docbook:395
+msgid "close the session"
+msgstr ""
+
+#: index.docbook:400
+msgid "handle exceptions"
+msgstr ""
+
+#: index.docbook:406
+msgid "Flushing the session has been discussed earlier, we'll now have a closer look at transaction demarcation and exception handling in both managed- and non-managed environments."
+msgstr ""
+
+#: index.docbook:413
+msgid "Non-managed environment"
+msgstr ""
+
+#: index.docbook:415
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e. non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr ""
+
+#: index.docbook:422
+msgid ""
+ "<![CDATA[// Non-managed environment idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:424
+msgid "You don't have to <literal>flush()</literal> the <literal>Session</literal> explicitly - the call to <literal>commit()</literal> automatically triggers the synchronization (depending upon the <xref linkend=\"objectstate-flushing\"/>FlushMode for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr ""
+
+#: index.docbook:433
+msgid "A much more flexible solution is Hibernate's built-in \"current session\" context management, as described earlier:"
+msgstr ""
+
+#: index.docbook:438
+msgid ""
+ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
+ "try {\n"
+ " factory.getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " factory.getCurrentSession().getTransaction().commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " factory.getCurrentSession().getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:440
+msgid "You will very likely never see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls (in the persistence layer) and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit) are in different layers. The current context management by Hibernate can significantly simplify this design, as all you need is access to a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr ""
+
+#: index.docbook:450
+msgid "Note that you should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> (which is the default), and for the second example <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr ""
+
+#: index.docbook:459
+msgid "Using JTA"
+msgstr ""
+
+#: index.docbook:461
+msgid "If your persistence layer runs in an application server (e.g. behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr ""
+
+#: index.docbook:468
+msgid "If you use bean-managed transactions (BMT) Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. So, the transaction management code is identical to the non-managed environment."
+msgstr ""
+
+#: index.docbook:474
+msgid ""
+ "<![CDATA[// BMT idiom\n"
+ "Session sess = factory.openSession();\n"
+ "Transaction tx = null;\n"
+ "try {\n"
+ " tx = sess.beginTransaction();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " if (tx != null) tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:476
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, you will have to use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr ""
+
+#: index.docbook:482
+msgid ""
+ "<![CDATA[// BMT idiom with getCurrentSession()\n"
+ "try {\n"
+ " UserTransaction tx = (UserTransaction)new InitialContext()\n"
+ " .lookup(\"java:comp/UserTransaction\");\n"
+ "\n"
+ " tx.begin();\n"
+ "\n"
+ " // Do some work on Session bound to transaction\n"
+ " factory.getCurrentSession().load(...);\n"
+ " factory.getCurrentSession().persist(...);\n"
+ "\n"
+ " tx.commit();\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " tx.rollback();\n"
+ " throw e; // or display error message\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:484
+msgid "With CMT, transaction demarcation is done in session bean deployment descriptors, not programatically, hence, the code is reduced to:"
+msgstr ""
+
+#: index.docbook:489
+msgid ""
+ "<![CDATA[// CMT idiom\n"
+ " Session sess = factory.getCurrentSession();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "]]>"
+msgstr ""
+
+#: index.docbook:491
+msgid "In a CMT/EJB even rollback happens automatically, since an unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>This means you do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr ""
+
+#: index.docbook:499
+msgid "Note that you should choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean, when you configure Hibernate's transaction factory. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Furthermore, make sure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatiblity), or set to <literal>\"jta\"</literal>."
+msgstr ""
+
+#: index.docbook:508
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a silly limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicity from a <literal>finally</literal> block. (Of course, most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> at all from the JTA or CMT code.)"
+msgstr ""
+
+#: index.docbook:524
+msgid "Exception handling"
+msgstr ""
+
+#: index.docbook:526
+msgid "If the <literal>Session</literal> throws an exception (including any <literal>SQLException</literal>), you should immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr ""
+
+#: index.docbook:537
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception (it wasn't in older versions of Hibernate). In our opinion, we shouldn't force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e. in higher layers) and an error message is presented to the application user (or some other appropriate action is taken). Note that Hibernate might also throw other unchecked exceptions which are not a <literal>HibernateException</literal>. These are, again, not recoverable and appropriate action should be taken."
+msgstr ""
+
+#: index.docbook:549
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the eexception into a more meningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect; however, it is also possible to plug in a custom implementation (see the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details). The standard <literal>JDBCException</literal> subtypes are:"
+msgstr ""
+
+#: index.docbook:565
+msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication."
+msgstr ""
+
+#: index.docbook:571
+msgid "<literal>SQLGrammarException</literal> - indicates a grammar or syntax problem with the issued SQL."
+msgstr ""
+
+#: index.docbook:577
+msgid "<literal>ConstraintViolationException</literal> - indicates some form of integrity constraint violation."
+msgstr ""
+
+#: index.docbook:583
+msgid "<literal>LockAcquisitionException</literal> - indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr ""
+
+#: index.docbook:589
+msgid "<literal>GenericJDBCException</literal> - a generic exception which did not fall into any of the other categories."
+msgstr ""
+
+#: index.docbook:599
+msgid "Transaction timeout"
+msgstr ""
+
+#: index.docbook:601
+msgid "One extremely important feature provided by a managed environment like EJB that is never provided for non-managed code is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functioanlity is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr ""
+
+#: index.docbook:614
+msgid ""
+ "<![CDATA[\n"
+ "Session sess = factory.openSession();\n"
+ "try {\n"
+ " //set transaction timeout to 3 seconds\n"
+ " sess.getTransaction().setTimeout(3);\n"
+ " sess.getTransaction().begin();\n"
+ "\n"
+ " // do some work\n"
+ " ...\n"
+ "\n"
+ " sess.getTransaction().commit()\n"
+ "}\n"
+ "catch (RuntimeException e) {\n"
+ " sess.getTransaction().rollback();\n"
+ " throw e; // or display error message\n"
+ "}\n"
+ "finally {\n"
+ " sess.close();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:616
+msgid "Note that <literal>setTimeout()</literal> may not be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr ""
+
+#: index.docbook:626
+msgid "Optimistic concurrency control"
+msgstr ""
+
+#: index.docbook:628
+msgid "The only approach that is consistent with high concurrency and high scalability is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates (and to prevent lost updates). Hibernate provides for three possible approaches to writing application code that uses optimistic concurrency. The use cases we show are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr ""
+
+#: index.docbook:639
+msgid "Application version checking"
+msgstr ""
+
+#: index.docbook:641
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr ""
+
+#: index.docbook:650
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "\n"
+ "int oldVersion = foo.getVersion();\n"
+ "session.load( foo, foo.getKey() ); // load the current state\n"
+ "if ( oldVersion != foo.getVersion() ) throw new StaleObjectStateException();\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:652
+msgid "The <literal>version</literal> property is mapped using <literal><version></literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr ""
+
+#: index.docbook:658
+msgid "Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check. In that case, <emphasis>last commit wins</emphasis> will be the default strategy for your long conversations. Keep in mind that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr ""
+
+#: index.docbook:667
+msgid "Clearly, manual version checking is only feasible in very trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified ojects have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr ""
+
+#: index.docbook:678
+msgid "Extended session and automatic versioning"
+msgstr ""
+
+#: index.docbook:680
+msgid "A single <literal>Session</literal> instance and its persistent instances are used for the whole conversation, known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data)."
+msgstr ""
+
+#: index.docbook:689
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances, nor does it have to reload instances in every database transaction."
+msgstr ""
+
+#: index.docbook:697
+msgid ""
+ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
+ "Transaction t = session.beginTransaction(); // Obtain a new JDBC connection, start transaction\n"
+ "\n"
+ "foo.setProperty(\"bar\");\n"
+ "\n"
+ "session.flush(); // Only for last transaction in conversation\n"
+ "t.commit(); // Also return JDBC connection\n"
+ "session.close(); // Only for last transaction in conversation]]>"
+msgstr ""
+
+#: index.docbook:698
+msgid "The <literal>foo</literal> object still knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you aren't updating, you may call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You don't need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Hence, only this last database transaction would include the <literal>flush()</literal> operation, and then also <literal>close()!
</literal> the session to end the conversation."
+msgstr ""
+
+#: index.docbook:713
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time, e.g. an <literal>HttpSession</literal> should be kept as small as possible. As the <literal>Session</literal> is also the (mandatory) first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. You should use a <literal>Session</literal> only for a single conversation, as it will soon also have stale data."
+msgstr ""
+
+#: index.docbook:723
+msgid "(Note that earlier Hibernate versions required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect.)"
+msgstr ""
+
+#: index.docbook:729
+msgid "Also note that you should keep the disconnected <literal>Session</literal> close to the persistence layer. In other words, use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment, and don't transfer it to the web layer (or even serialize it to a separate tier) to store it in the <literal>HttpSession</literal>."
+msgstr ""
+
+#: index.docbook:737
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this, see the Hibernate Wiki for examples."
+msgstr ""
+
+#: index.docbook:747
+msgid "Detached objects and automatic versioning"
+msgstr ""
+
+#: index.docbook:749
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr ""
+
+#: index.docbook:757
+msgid ""
+ "<![CDATA[// foo is an instance loaded by a previous Session\n"
+ "foo.setProperty(\"bar\");\n"
+ "session = factory.openSession();\n"
+ "Transaction t = session.beginTransaction();\n"
+ "session.saveOrUpdate(foo); // Use merge() if \"foo\" might have been loaded already\n"
+ "t.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:759
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured."
+msgstr ""
+
+#: index.docbook:764
+msgid "You may also call <literal>lock()</literal> instead of <literal>update()</literal> and use <literal>LockMode.READ</literal> (performing a version check, bypassing all caches) if you are sure that the object has not been modified."
+msgstr ""
+
+#: index.docbook:773
+msgid "Customizing automatic versioning"
+msgstr ""
+
+#: index.docbook:775
+msgid "You may disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr ""
+
+#: index.docbook:782
+msgid "Legacy database schemas are often static and can't be modified. Or, other applications might also access the same database and don't know how to handle version numbers or even timestamps. In both cases, versioning can't rely on a particular column in a table. To force a version check without a version or timestamp property mapping, with a comparison of the state of all fields in a row, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal><class></literal> mapping. Note that this concepetually only works if Hibernate can compare the old and new state, i.e. if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects."
+msgstr ""
+
+#: index.docbook:793
+msgid "Sometimes concurrent modification can be permitted as long as the changes that have been made don't overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal><class></literal>, Hibernate will only compare dirty fields during flush."
+msgstr ""
+
+#: index.docbook:799
+msgid "In both cases, with dedicated version/timestamp columns or with full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement (with an appropriate <literal>WHERE</literal> clause) per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate might execute uneccessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal><class></literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row."
+msgstr ""
+
+#: index.docbook:817
+msgid "Pessimistic Locking"
+msgstr ""
+
+#: index.docbook:819
+msgid "It is not intended that users spend much time worring about locking strategies. Its usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may sometimes wish to obtain exclusive pessimistic locks, or re-obtain locks at the start of a new transaction."
+msgstr ""
+
+#: index.docbook:826
+msgid "Hibernate will always use the locking mechanism of the database, never lock objects in memory!"
+msgstr ""
+
+#: index.docbook:831
+msgid "The <literal>LockMode</literal> class defines the different lock levels that may be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr ""
+
+#: index.docbook:838
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr ""
+
+#: index.docbook:844
+msgid "<literal>LockMode.UPGRADE</literal> may be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr ""
+
+#: index.docbook:850
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> may be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr ""
+
+#: index.docbook:856
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. May be re-acquired by explicit user request."
+msgstr ""
+
+#: index.docbook:863
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr ""
+
+#: index.docbook:872
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
+msgstr ""
+
+#: index.docbook:878
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr ""
+
+#: index.docbook:883
+msgid "A call to <literal>Session.lock()</literal>."
+msgstr ""
+
+#: index.docbook:888
+msgid "A call to <literal>Query.setLockMode()</literal>."
+msgstr ""
+
+#: index.docbook:894
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr ""
+
+#: index.docbook:903
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. (In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used.)"
+msgstr ""
+
+#: index.docbook:910
+msgid "If the database does not support the requested lock mode, Hibernate will use an appropriate alternate mode (instead of throwing an exception). This ensures that applications will be portable."
+msgstr ""
+
+#: index.docbook:919
+msgid "Connection Release Modes"
+msgstr ""
+
+#: index.docbook:921
+msgid "The legacy (2.x) behavior of Hibernate in regards to JDBC connection management was that a <literal>Session</literal> would obtain a connection when it was first needed and then hold unto that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes to tell a session how to handle its JDBC connections. Note that the following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>; user-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr ""
+
+#: index.docbook:935
+msgid "<literal>ON_CLOSE</literal> - is essentially the legacy behavior described above. The Hibernate session obatins a connection when it first needs to perform some JDBC access and holds unto that connection until the session is closed."
+msgstr ""
+
+#: index.docbook:942
+msgid "<literal>AFTER_TRANSACTION</literal> - says to release connections after a <literal>org.hibernate.Transaction</literal> has completed."
+msgstr ""
+
+#: index.docbook:948
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release) - says to release connections after each and every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session; currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr ""
+
+#: index.docbook:958
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values:"
+msgstr ""
+
+#: index.docbook:965
+msgid "<literal>auto</literal> (the default) - this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. It is rarely a good idea to change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr ""
+
+#: index.docbook:975
+msgid "<literal>on_close</literal> - says to use ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is highly discouraged."
+msgstr ""
+
+#: index.docbook:981
+msgid "<literal>after_transaction</literal> - says to use ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr ""
+
+#: index.docbook:989
+msgid "<literal>after_statement</literal> - says to use ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time we make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter whether we get back the same connection."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/tutorial.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/tutorial.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/tutorial.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,1315 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:7
+msgid "Introduction to Hibernate"
+msgstr ""
+
+#: index.docbook:10
+msgid "Preface"
+msgstr ""
+
+#: index.docbook:12
+msgid "This chapter is an introductory tutorial for new users of Hibernate. We start with a simple command line application using an in-memory database and develop it in easy to understand steps."
+msgstr ""
+
+#: index.docbook:18
+msgid "This tutorial is intended for new users of Hibernate but requires Java and SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
+msgstr ""
+
+#: index.docbook:24
+msgid "The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr ""
+
+#: index.docbook:32
+msgid "Part 1 - The first Hibernate Application"
+msgstr ""
+
+#: index.docbook:34
+msgid "First, we'll create a simple console-based Hibernate application. We use an Java database (HSQL DB), so we do not have to install any database server."
+msgstr ""
+
+#: index.docbook:39
+msgid "Let's assume we need a small database application that can store events we want to attend, and information about the hosts of these events."
+msgstr ""
+
+#: index.docbook:44
+msgid "The first thing we do, is set up our development directory and put all the Java libraries we need into it. Download the Hibernate distribution from the Hibernate website. Extract the package and place all required libraries found in <literal>/lib</literal> into into the <literal>/lib</literal> directory of your new development working directory. It should look like this:"
+msgstr ""
+
+#: index.docbook:52
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " antlr.jar\n"
+ " cglib.jar\n"
+ " asm.jar\n"
+ " asm-attrs.jars\n"
+ " commons-collections.jar\n"
+ " commons-logging.jar\n"
+ " hibernate3.jar\n"
+ " jta.jar\n"
+ " dom4j.jar\n"
+ " log4j.jar ]]>"
+msgstr ""
+
+#: index.docbook:54
+msgid "This is the minimum set of required libraries (note that we also copied hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of writing</emphasis>. The Hibernate release you are using might require more or less libraries. See the <literal>README.txt</literal> file in the <literal>lib/</literal> directory of the Hibernate distribution for more information about required and optional third-party libraries. (Actually, Log4j is not required but preferred by many developers.)"
+msgstr ""
+
+#: index.docbook:63
+msgid "Next we create a class that represents the event we want to store in database."
+msgstr ""
+
+#: index.docbook:68
+msgid "The first class"
+msgstr ""
+
+#: index.docbook:70
+msgid "Our first persistent class is a simple JavaBean class with some properties:"
+msgstr ""
+
+#: index.docbook:74
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "public class Event {\n"
+ " private Long id;\n"
+ "\n"
+ " private String title;\n"
+ " private Date date;\n"
+ "\n"
+ " public Event() {}\n"
+ "\n"
+ " public Long getId() {\n"
+ " return id;\n"
+ " }\n"
+ "\n"
+ " private void setId(Long id) {\n"
+ " this.id = id;\n"
+ " }\n"
+ "\n"
+ " public Date getDate() {\n"
+ " return date;\n"
+ " }\n"
+ "\n"
+ " public void setDate(Date date) {\n"
+ " this.date = date;\n"
+ " }\n"
+ "\n"
+ " public String getTitle() {\n"
+ " return title;\n"
+ " }\n"
+ "\n"
+ " public void setTitle(String title) {\n"
+ " this.title = title;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:76
+msgid "You can see that this class uses standard JavaBean naming conventions for property getter and setter methods, as well as private visibility for the fields. This is a recommended design - but not required. Hibernate can also access fields directly, the benefit of accessor methods is robustness for refactoring. The no-argument constructor is required to instantiate an object of this class through reflection."
+msgstr ""
+
+#: index.docbook:84
+msgid "The <literal>id</literal> property holds a unique identifier value for a particular event. All persistent entity classes (there are less important dependent classes as well) will need such an identifier property if we want to use the full feature set of Hibernate. In fact, most applications (esp. web applications) need to distinguish objects by identifier, so you should consider this a feature rather than a limitation. However, we usually don't manipulate the identity of an object, hence the setter method should be private. Only Hibernate will assign identifiers when an object is saved. You can see that Hibernate can access public, private, and protected accessor methods, as well as (public, private, protected) fields directly. The choice is up to you and you can match it to fit your application design."
+msgstr ""
+
+#: index.docbook:96
+msgid "The no-argument constructor is a requirement for all persistent classes; Hibernate has to create objects for you, using Java Reflection. The constructor can be private, however, package visibility is required for runtime proxy generation and efficient data retrieval without bytecode instrumentation."
+msgstr ""
+
+#: index.docbook:103
+msgid "Place this Java source file in a directory called <literal>src</literal> in the development folder, and in its correct package. The directory should now look like this:"
+msgstr ""
+
+#: index.docbook:108
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java]]>"
+msgstr ""
+
+#: index.docbook:110
+msgid "In the next step, we tell Hibernate about this persistent class."
+msgstr ""
+
+#: index.docbook:117
+msgid "The mapping file"
+msgstr ""
+
+#: index.docbook:119
+msgid "Hibernate needs to know how to load and store objects of the persistent class. This is where the Hibernate mapping file comes into play. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use."
+msgstr ""
+
+#: index.docbook:126
+msgid "The basic structure of a mapping file looks like this:"
+msgstr ""
+
+#: index.docbook:130
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\"?>\n"
+ "<!DOCTYPE hibernate-mapping PUBLIC\n"
+ " \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-mapping>\n"
+ "[...]\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:132
+msgid "Note that the Hibernate DTD is very sophisticated. You can use it for auto-completion of XML mapping elements and attributes in your editor or IDE. You also should open up the DTD file in your text editor - it's the easiest way to get an overview of all elements and attributes and to see the defaults, as well as some comments. Note that Hibernate will not load the DTD file from the web, but first look it up from the classpath of the application. The DTD file is included in <literal>hibernate3.jar</literal> as well as in the <literal>src/</literal> directory of the Hibernate distribution."
+msgstr ""
+
+#: index.docbook:143
+msgid "We will omit the DTD declaration in future examples to shorten the code. It is of course not optional."
+msgstr ""
+
+#: index.docbook:148
+msgid "Between the two <literal>hibernate-mapping</literal> tags, include a <literal>class</literal> element. All persistent entity classes (again, there might be dependent classes later on, which are not first-class entities) need such a mapping, to a table in the SQL database:"
+msgstr ""
+
+#: index.docbook:155
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ "\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:157
+msgid "So far we told Hibernate how to persist and load object of class <literal>Event</literal> to the table <literal>EVENTS</literal>, each instance represented by a row in that table. Now we continue with a mapping of the unique identifier property to the tables primary key. In addition, as we don't want to care about handling this identifier, we configure Hibernate's identifier generation strategy for a surrogate primary key column:"
+msgstr ""
+
+#: index.docbook:165
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:167
+msgid "The <literal>id</literal> element is the declaration of the identifer property, <literal>name=\"id\"</literal> declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column attribute tells Hibernate which column of the <literal>EVENTS</literal> table we use for this primary key. The nested <literal>generator</literal> element specifies the identifier generation strategy, in this case we used <literal>native</literal>, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally unique, as well as application assigned identifiers (or any strategy you have written an extension for)."
+msgstr ""
+
+#: index.docbook:180
+msgid "Finally we include declarations for the persistent properties of the class in the mapping file. By default, no properties of the class are considered persistent:"
+msgstr ""
+
+#: index.docbook:186
+msgid ""
+ "<![CDATA[\n"
+ "<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Event\" table=\"EVENTS\">\n"
+ " <id name=\"id\" column=\"EVENT_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"date\" type=\"timestamp\" column=\"EVENT_DATE\"/>\n"
+ " <property name=\"title\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:188
+msgid "Just as with the <literal>id</literal> element, the <literal>name</literal> attribute of the <literal>property</literal> element tells Hibernate which getter and setter methods to use. So, in this case, Hibernate will look for <literal>getDate()/setDate()</literal>, as well as <literal>getTitle()/setTitle()</literal>."
+msgstr ""
+
+#: index.docbook:195
+msgid "Why does the <literal>date</literal> property mapping include the <literal>column</literal> attribute, but the <literal>title</literal> doesn't? Without the <literal>column</literal> attribute Hibernate by default uses the property name as the column name. This works fine for <literal>title</literal>. However, <literal>date</literal> is a reserved keyword in most database, so we better map it to a different name."
+msgstr ""
+
+#: index.docbook:204
+msgid "The next interesting thing is that the <literal>title</literal> mapping also lacks a <literal>type</literal> attribute. The types we declare and use in the mapping files are not, as you might expect, Java data types. They are also not SQL database types. These types are so called <emphasis>Hibernate mapping types</emphasis>, converters which can translate from Java to SQL data types and vice versa. Again, Hibernate will try to determine the correct conversion and mapping type itself if the <literal>type</literal> attribute is not present in the mapping. In some cases this automatic detection (using Reflection on the Java class) might not have the default you expect or need. This is the case with the <literal>date</literal> property. Hibernate can't know if the property (which is of <literal>java.util.Date</literal>) should map to a SQL <literal>date</literal>, <literal>timestamp</literal>, or <literal>time</literal> column. We preserve full date and time information !
by mapping the property with a <literal>timestamp</literal> converter."
+msgstr ""
+
+#: index.docbook:220
+msgid "This mapping file should be saved as <literal>Event.hbm.xml</literal>, right in the directory next to the <literal>Event</literal> Java class source file. The naming of mapping files can be arbitrary, however the <literal>hbm.xml</literal> suffix is a convention in the Hibernate developer community. The directory structure should now look like this:"
+msgstr ""
+
+#: index.docbook:228
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml]]>"
+msgstr ""
+
+#: index.docbook:230
+msgid "We continue with the main configuration of Hibernate."
+msgstr ""
+
+#: index.docbook:237
+msgid "Hibernate configuration"
+msgstr ""
+
+#: index.docbook:239
+msgid "We now have a persistent class and its mapping file in place. It is time to configure Hibernate. Before we do this, we will need a database. HSQL DB, a java-based SQL DBMS, can be downloaded from the HSQL DB website(http://hsqldb.org/). Actually, you only need the <literal>hsqldb.jar</literal> from this download. Place this file in the <literal>lib/</literal> directory of the development folder."
+msgstr ""
+
+#: index.docbook:247
+msgid "Create a directory called <literal>data</literal> in the root of the development directory - this is where HSQL DB will store its data files. Now start the database by running <literal>java -classpath ../lib/hsqldb.jar org.hsqldb.Server</literal> in this data directory. You can see it start up and bind to a TCP/IP socket, this is where our application will connect later. If you want to start with a fresh database during this tutorial, shutdown HSQL DB (press <literal>CTRL + C</literal> in the window), delete all files in the <literal>data/</literal> directory, and start HSQL DB again."
+msgstr ""
+
+#: index.docbook:257
+msgid "Hibernate is the layer in your application which connects to this database, so it needs connection information. The connections are made through a JDBC connection pool, which we also have to configure. The Hibernate distribution contains several open source JDBC connection pooling tools, but will use the Hibernate built-in connection pool for this tutorial. Note that you have to copy the required library into your classpath and use different connection pooling settings if you want to use a production-quality third party JDBC pooling software."
+msgstr ""
+
+#: index.docbook:267
+msgid "For Hibernate's configuration, we can use a simple <literal>hibernate.properties</literal> file, a slightly more sophisticated <literal>hibernate.cfg.xml</literal> file, or even complete programmatic setup. Most users prefer the XML configuration file:"
+msgstr ""
+
+#: index.docbook:273
+msgid ""
+ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
+ "<!DOCTYPE hibernate-configuration PUBLIC\n"
+ " \"-//Hibernate/Hibernate Configuration DTD 3.0//EN\"\n"
+ " \"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd\">\n"
+ "\n"
+ "<hibernate-configuration>\n"
+ "\n"
+ " <session-factory>\n"
+ "\n"
+ " <!-- Database connection settings -->\n"
+ " <property name=\"connection.driver_class\">org.hsqldb.jdbcDriver</property>\n"
+ " <property name=\"connection.url\">jdbc:hsqldb:hsql://localhost</property>\n"
+ " <property name=\"connection.username\">sa</property>\n"
+ " <property name=\"connection.password\"></property>\n"
+ "\n"
+ " <!-- JDBC connection pool (use the built-in) -->\n"
+ " <property name=\"connection.pool_size\">1</property>\n"
+ "\n"
+ " <!-- SQL dialect -->\n"
+ " <property name=\"dialect\">org.hibernate.dialect.HSQLDialect</property>\n"
+ "\n"
+ " <!-- Enable Hibernate's automatic session context management -->\n"
+ " <property name=\"current_session_context_class\">thread</property>\n"
+ "\n"
+ " <!-- Disable the second-level cache -->\n"
+ " <property name=\"cache.provider_class\">org.hibernate.cache.NoCacheProvider</property>\n"
+ "\n"
+ " <!-- Echo all executed SQL to stdout -->\n"
+ " <property name=\"show_sql\">true</property>\n"
+ "\n"
+ " <!-- Drop and re-create the database schema on startup -->\n"
+ " <property name=\"hbm2ddl.auto\">create</property>\n"
+ "\n"
+ " <mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "\n"
+ " </session-factory>\n"
+ "\n"
+ "</hibernate-configuration>]]>"
+msgstr ""
+
+#: index.docbook:275
+msgid "Note that this XML configuration uses a different DTD. We configure Hibernate's <literal>SessionFactory</literal> - a global factory responsible for a particular database. If you have several databases, use several <literal><session-factory></literal> configurations, usually in several configuration files (for easier startup)."
+msgstr ""
+
+#: index.docbook:283
+msgid "The first four <literal>property</literal> elements contain the necessary configuration for the JDBC connection. The dialect <literal>property</literal> element specifies the particular SQL variant Hibernate generates. Hibernate's automatic session management for persistence contexts will come in handy as you will soon see. The <literal>hbm2ddl.auto</literal> option turns on automatic generation of database schemas - directly into the database. This can of course also be turned off (by removing the config option) or redirected to a file with the help of the <literal>SchemaExport</literal> Ant task. Finally, we add the mapping file(s) for persistent classes to the configuration."
+msgstr ""
+
+#: index.docbook:296
+msgid "Copy this file into the source directory, so it will end up in the root of the classpath. Hibernate automatically looks for a file called <literal>hibernate.cfg.xml</literal> in the root of the classpath, on startup."
+msgstr ""
+
+#: index.docbook:305
+msgid "Building with Ant"
+msgstr ""
+
+#: index.docbook:307
+msgid "We'll now build the tutorial with Ant. You will need to have Ant installed - get it from the <ulink url=\"http://ant.apache.org/bindownload.cgi\">Ant download page</ulink>. How to install Ant will not be covered here. Please refer to the <ulink url=\"http://ant.apache.org/manual/index.html\">Ant manual</ulink>. After you have installed Ant, we can start to create the buildfile. It will be called <literal>build.xml</literal> and placed directly in the development directory."
+msgstr ""
+
+#: index.docbook:316
+msgid "A basic build file looks like this:"
+msgstr ""
+
+#: index.docbook:320
+msgid ""
+ "<![CDATA[<project name=\"hibernate-tutorial\" default=\"compile\">\n"
+ "\n"
+ " <property name=\"sourcedir\" value=\"${basedir}/src\"/>\n"
+ " <property name=\"targetdir\" value=\"${basedir}/bin\"/>\n"
+ " <property name=\"librarydir\" value=\"${basedir}/lib\"/>\n"
+ "\n"
+ " <path id=\"libraries\">\n"
+ " <fileset dir=\"${librarydir}\">\n"
+ " <include name=\"*.jar\"/>\n"
+ " </fileset>\n"
+ " </path>\n"
+ "\n"
+ " <target name=\"clean\">\n"
+ " <delete dir=\"${targetdir}\"/>\n"
+ " <mkdir dir=\"${targetdir}\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"compile\" depends=\"clean, copy-resources\">\n"
+ " <javac srcdir=\"${sourcedir}\"\n"
+ " destdir=\"${targetdir}\"\n"
+ " classpathref=\"libraries\"/>\n"
+ " </target>\n"
+ "\n"
+ " <target name=\"copy-resources\">\n"
+ " <copy todir=\"${targetdir}\">\n"
+ " <fileset dir=\"${sourcedir}\">\n"
+ " <exclude name=\"**/*.java\"/>\n"
+ " </fileset>\n"
+ " </copy>\n"
+ " </target>\n"
+ "\n"
+ "</project>]]>"
+msgstr ""
+
+#: index.docbook:322
+msgid "This will tell Ant to add all files in the lib directory ending with <literal>.jar</literal> to the classpath used for compilation. It will also copy all non-Java source files to the target directory, e.g. configuration and Hibernate mapping files. If you now run Ant, you should get this output:"
+msgstr ""
+
+#: index.docbook:329
+msgid ""
+ "<![CDATA[C:\\hibernateTutorial\\>ant\n"
+ "Buildfile: build.xml\n"
+ "\n"
+ "copy-resources:\n"
+ " [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "compile:\n"
+ " [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
+ "\n"
+ "BUILD SUCCESSFUL\n"
+ "Total time: 1 second ]]>"
+msgstr ""
+
+#: index.docbook:334
+msgid "Startup and helpers"
+msgstr ""
+
+#: index.docbook:336
+msgid "It's time to load and store some <literal>Event</literal> objects, but first we have to complete the setup with some infrastructure code. We have to startup Hibernate. This startup includes building a global <literal>SessionFactory</literal> object and to store it somewhere for easy access in application code. A <literal>SessionFactory</literal> can open up new <literal>Session</literal>'s. A <literal>Session</literal> represents a single-threaded unit of work, the <literal>SessionFactory</literal> is a thread-safe global object, instantiated once."
+msgstr ""
+
+#: index.docbook:346
+msgid "We'll create a <literal>HibernateUtil</literal> helper class which takes care of startup and makes accessing a <literal>SessionFactory</literal> convenient. Let's have a look at the implementation:"
+msgstr ""
+
+#: index.docbook:352
+msgid ""
+ "<![CDATA[package util;\n"
+ "\n"
+ "import org.hibernate.*;\n"
+ "import org.hibernate.cfg.*;\n"
+ "\n"
+ "public class HibernateUtil {\n"
+ "\n"
+ " private static final SessionFactory sessionFactory;\n"
+ "\n"
+ " static {\n"
+ " try {\n"
+ " // Create the SessionFactory from hibernate.cfg.xml\n"
+ " sessionFactory = new Configuration().configure().buildSessionFactory();\n"
+ " } catch (Throwable ex) {\n"
+ " // Make sure you log the exception, as it might be swallowed\n"
+ " System.err.println(\"Initial SessionFactory creation failed.\" + ex);\n"
+ " throw new ExceptionInInitializerError(ex);\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " public static SessionFactory getSessionFactory() {\n"
+ " return sessionFactory;\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:354
+msgid "This class does not only produce the global <literal>SessionFactory</literal> in its static initializer (called once by the JVM when the class is loaded), but also hides the fact that it uses a static singleton. It might as well lookup the <literal>SessionFactory</literal> from JNDI in an application server."
+msgstr ""
+
+#: index.docbook:361
+msgid "If you give the <literal>SessionFactory</literal> a name in your configuration file, Hibernate will in fact try to bind it to JNDI after it has been built. To avoid this code completely you could also use JMX deployment and let the JMX-capable container instantiate and bind a <literal>HibernateService</literal> to JNDI. These advanced options are discussed in the Hibernate reference documentation."
+msgstr ""
+
+#: index.docbook:370
+msgid "Place <literal>HibernateUtil.java</literal> in the development source directory, in a package next to <literal>events</literal>:"
+msgstr ""
+
+#: index.docbook:375
+msgid ""
+ "<![CDATA[.\n"
+ "+lib\n"
+ " <Hibernate and third-party libraries>\n"
+ "+src\n"
+ " +events\n"
+ " Event.java\n"
+ " Event.hbm.xml\n"
+ " +util\n"
+ " HibernateUtil.java\n"
+ " hibernate.cfg.xml\n"
+ "+data\n"
+ "build.xml]]>"
+msgstr ""
+
+#: index.docbook:377
+msgid "This should again compile without problems. We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy <literal>log4j.properties</literal> from the Hibernate distribution (it's in the <literal>etc/</literal> directory) to your <literal>src</literal> directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout."
+msgstr ""
+
+#: index.docbook:387
+msgid "The tutorial infrastructure is complete - and we are ready to do some real work with Hibernate."
+msgstr ""
+
+#: index.docbook:395
+msgid "Loading and storing objects"
+msgstr ""
+
+#: index.docbook:397
+msgid "Finally, we can use Hibernate to load and store objects. We write an <literal>EventManager</literal> class with a <literal>main()</literal> method:"
+msgstr ""
+
+#: index.docbook:402
+msgid ""
+ "<![CDATA[package events;\n"
+ "import org.hibernate.Session;\n"
+ "\n"
+ "import java.util.Date;\n"
+ "\n"
+ "import util.HibernateUtil;\n"
+ "\n"
+ "public class EventManager {\n"
+ "\n"
+ " public static void main(String[] args) {\n"
+ " EventManager mgr = new EventManager();\n"
+ "\n"
+ " if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " }\n"
+ "\n"
+ " HibernateUtil.getSessionFactory().close();\n"
+ " }\n"
+ "\n"
+ " private void createAndStoreEvent(String title, Date theDate) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " session.save(theEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:404
+msgid "We create a new <literal>Event</literal> object, and hand it over to Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</literal>s on the database. Let's have a look at the <literal>Session</literal> and <literal>Transaction</literal>-handling code before we run this."
+msgstr ""
+
+#: index.docbook:411
+msgid "A <literal>Session</literal> is a single unit of work. For now we'll keep things simple and assume a one-to-one granularity between a Hibernate <literal>Session</literal> and a database transaction. To shield our code from the actual underlying transaction system (in this case plain JDBC, but it could also run with JTA) we use the <literal>Transaction</literal> API that is available on the Hibernate <literal>Session</literal>."
+msgstr ""
+
+#: index.docbook:419
+msgid "What does <literal>sessionFactory.getCurrentSession()</literal> do? First, you can call it as many times and anywhere you like, once you get hold of your <literal>SessionFactory</literal> (easy thanks to <literal>HibernateUtil</literal>). The <literal>getCurrentSession()</literal> method always returns the \"current\" unit of work. Remember that we switched the configuration option for this mechanism to \"thread\" in <literal>hibernate.cfg.xml</literal>? Hence, the current unit of work is bound to the current Java thread that executes our application. However, this is not the full picture, you also have to consider scope, when a unit of work begins and when it ends."
+msgstr ""
+
+#: index.docbook:430
+msgid "A <literal>Session</literal> begins when it is first needed, when the first call to <literal>getCurrentSession()</literal> is made. It is then bound by Hibernate to the current thread. When the transaction ends, either through commit or rollback, Hibernate automatically unbinds the <literal>Session</literal> from the thread and closes it for you. If you call <literal>getCurrentSession()</literal> again, you get a new <literal>Session</literal> and can start a new unit of work. This <emphasis>thread-bound</emphasis> programming model is the most popular way of using Hibernate, as it allows flexible layering of your code (transaction demarcation code can be separated from data access code, we'll do this later in this tutorial)."
+msgstr ""
+
+#: index.docbook:441
+msgid "Related to the unit of work scope, should the Hibernate <literal>Session</literal> be used to execute one or several database operations? The above example uses one <literal>Session</literal> for one operation. This is pure coincidence, the example is just not complex enough to show any other approach. The scope of a Hibernate <literal>Session</literal> is flexible but you should never design your application to use a new Hibernate <literal>Session</literal> for <emphasis>every</emphasis> database operation. So even if you see it a few more times in the following (very trivial) examples, consider <emphasis>session-per-operation</emphasis> an anti-pattern. A real (web) application is shown later in this tutorial."
+msgstr ""
+
+#: index.docbook:452
+msgid "Have a look at <xref linkend=\"transactions\"/> for more information about transaction handling and demarcation. We also skipped any error handling and rollback in the previous example."
+msgstr ""
+
+#: index.docbook:458
+msgid "To run this first routine we have to add a callable target to the Ant build file:"
+msgstr ""
+
+#: index.docbook:462
+msgid ""
+ "<![CDATA[<target name=\"run\" depends=\"compile\">\n"
+ " <java fork=\"true\" classname=\"events.EventManager\" classpathref=\"libraries\">\n"
+ " <classpath path=\"${targetdir}\"/>\n"
+ " <arg value=\"${action}\"/>\n"
+ " </java>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:464
+msgid "The value of the <literal>action</literal> argument is set on the command line when calling the target:"
+msgstr ""
+
+#: index.docbook:469
+msgid "<![CDATA[C:\\hibernateTutorial\\>ant run -Daction=store]]>"
+msgstr ""
+
+#: index.docbook:471
+msgid "You should see, after compilation, Hibernate starting up and, depending on your configuration, lots of log output. At the end you will find the following line:"
+msgstr ""
+
+#: index.docbook:476
+msgid "<![CDATA[[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)]]>"
+msgstr ""
+
+#: index.docbook:478
+msgid "This is the <literal>INSERT</literal> executed by Hibernate, the question marks represent JDBC bind parameters. To see the values bound as arguments, or to reduce the verbosity of the log, check your <literal>log4j.properties</literal>."
+msgstr ""
+
+#: index.docbook:484
+msgid "Now we'd like to list stored events as well, so we add an option to the main method:"
+msgstr ""
+
+#: index.docbook:488
+msgid ""
+ "<![CDATA[if (args[0].equals(\"store\")) {\n"
+ " mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ "}\n"
+ "else if (args[0].equals(\"list\")) {\n"
+ " List events = mgr.listEvents();\n"
+ " for (int i = 0; i < events.size(); i++) {\n"
+ " Event theEvent = (Event) events.get(i);\n"
+ " System.out.println(\"Event: \" + theEvent.getTitle() +\n"
+ " \" Time: \" + theEvent.getDate());\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:490
+msgid "We also add a new <literal>listEvents() method</literal>:"
+msgstr ""
+
+#: index.docbook:494
+msgid ""
+ "<![CDATA[private List listEvents() {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ "\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " List result = session.createQuery(\"from Event\").list();\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " return result;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:496
+msgid "What we do here is use an HQL (Hibernate Query Language) query to load all existing <literal>Event</literal> objects from the database. Hibernate will generate the appropriate SQL, send it to the database and populate <literal>Event</literal> objects with the data. You can create more complex queries with HQL, of course."
+msgstr ""
+
+#: index.docbook:503
+msgid "Now, to execute and test all of this, follow these steps:"
+msgstr ""
+
+#: index.docbook:509
+msgid "Run <literal>ant run -Daction=store</literal> to store something into the database and, of course, to generate the database schema before through hbm2ddl."
+msgstr ""
+
+#: index.docbook:515
+msgid "Now disable hbm2ddl by commenting out the property in your <literal>hibernate.cfg.xml</literal> file. Usually you only leave it turned on in continous unit testing, but another run of hbm2ddl would <emphasis>drop</emphasis> everything you have stored - the <literal>create</literal> configuration setting actually translates into \"drop all tables from the schema, then re-create all tables, when the SessionFactory is build\"."
+msgstr ""
+
+#: index.docbook:525
+msgid "If you now call Ant with <literal>-Daction=list</literal>, you should see the events you have stored so far. You can of course also call the <literal>store</literal> action a few times more."
+msgstr ""
+
+#: index.docbook:531
+msgid "Note: Most new Hibernate users fail at this point and we see questions about <emphasis>Table not found</emphasis> error messages regularly. However, if you follow the steps outlined above you will not have this problem, as hbm2ddl creates the database schema on the first run, and subsequent application restarts will use this schema. If you change the mapping and/or database schema, you have to re-enable hbm2ddl once again."
+msgstr ""
+
+#: index.docbook:544
+msgid "Part 2 - Mapping associations"
+msgstr ""
+
+#: index.docbook:546
+msgid "We mapped a persistent entity class to a table. Let's build on this and add some class associations. First we'll add people to our application, and store a list of events they participate in."
+msgstr ""
+
+#: index.docbook:552
+msgid "Mapping the Person class"
+msgstr ""
+
+#: index.docbook:554
+msgid "The first cut of the <literal>Person</literal> class is simple:"
+msgstr ""
+
+#: index.docbook:558
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "public class Person {\n"
+ "\n"
+ " private Long id;\n"
+ " private int age;\n"
+ " private String firstname;\n"
+ " private String lastname;\n"
+ "\n"
+ " public Person() {}\n"
+ "\n"
+ " // Accessor methods for all properties, private setter for 'id'\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:560
+msgid "Create a new mapping file called <literal>Person.hbm.xml</literal> (don't forget the DTD reference at the top):"
+msgstr ""
+
+#: index.docbook:565
+msgid ""
+ "<![CDATA[<hibernate-mapping>\n"
+ "\n"
+ " <class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ " </class>\n"
+ "\n"
+ "</hibernate-mapping>]]>"
+msgstr ""
+
+#: index.docbook:567
+msgid "Finally, add the new mapping to Hibernate's configuration:"
+msgstr ""
+
+#: index.docbook:571
+msgid ""
+ "<![CDATA[<mapping resource=\"events/Event.hbm.xml\"/>\n"
+ "<mapping resource=\"events/Person.hbm.xml\"/>]]>"
+msgstr ""
+
+#: index.docbook:573
+msgid "We'll now create an association between these two entities. Obviously, persons can participate in events, and events have participants. The design questions we have to deal with are: directionality, multiplicity, and collection behavior."
+msgstr ""
+
+#: index.docbook:583
+msgid "A unidirectional Set-based association"
+msgstr ""
+
+#: index.docbook:585
+msgid "We'll add a collection of events to the <literal>Person</literal> class. That way we can easily navigate to the events for a particular person, without executing an explicit query - by calling <literal>aPerson.getEvents()</literal>. We use a Java collection, a <literal>Set</literal>, because the collection will not contain duplicate elements and the ordering is not relevant for us."
+msgstr ""
+
+#: index.docbook:592
+msgid "We need a unidirectional, many-valued associations, implemented with a <literal>Set</literal>. Let's write the code for this in the Java classes and then map it:"
+msgstr ""
+
+#: index.docbook:597
+msgid ""
+ "<![CDATA[public class Person {\n"
+ "\n"
+ " private Set events = new HashSet();\n"
+ "\n"
+ " public Set getEvents() {\n"
+ " return events;\n"
+ " }\n"
+ "\n"
+ " public void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:599
+msgid "Before we map this association, think about the other side. Clearly, we could just keep this unidirectional. Or, we could create another collection on the <literal>Event</literal>, if we want to be able to navigate it bi-directional, i.e. <literal>anEvent.getParticipants()</literal>. This is not necessary, from a functional perspective. You could always execute an explicit query to retrieve the participants for a particular event. This is a design choice left to you, but what is clear from this discussion is the multiplicity of the association: \"many\" valued on both sides, we call this a <emphasis>many-to-many</emphasis> association. Hence, we use Hibernate's many-to-many mapping:"
+msgstr ""
+
+#: index.docbook:610
+msgid ""
+ "<![CDATA[<class name=\"events.Person\" table=\"PERSON\">\n"
+ " <id name=\"id\" column=\"PERSON_ID\">\n"
+ " <generator class=\"native\"/>\n"
+ " </id>\n"
+ " <property name=\"age\"/>\n"
+ " <property name=\"firstname\"/>\n"
+ " <property name=\"lastname\"/>\n"
+ "\n"
+ " <set name=\"events\" table=\"PERSON_EVENT\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <many-to-many column=\"EVENT_ID\" class=\"events.Event\"/>\n"
+ " </set>\n"
+ "\n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:612
+msgid "Hibernate supports all kinds of collection mappings, a <literal><set></literal> being most common. For a many-to-many association (or <emphasis>n:m</emphasis> entity relationship), an association table is needed. Each row in this table represents a link between a person and an event. The table name is configured with the <literal>table</literal> attribute of the <literal>set</literal> element. The identifier column name in the association, for the person's side, is defined with the <literal><key></literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal><many-to-many></literal>. You also have to tell Hibernate the class of the objects in your collection (correct: the class on the other side of the collection of references)."
+msgstr ""
+
+#: index.docbook:624
+msgid "The database schema for this mapping is therefore:"
+msgstr ""
+
+#: index.docbook:628
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | |\n"
+ " |_____________| |__________________| | PERSON |\n"
+ " | | | | |_____________|\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | |\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE |\n"
+ " |_____________| | FIRSTNAME |\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:633
+msgid "Working the association"
+msgstr ""
+
+#: index.docbook:635
+msgid "Let's bring some people and events together in a new method in <literal>EventManager</literal>:"
+msgstr ""
+
+#: index.docbook:639
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:641
+msgid "After loading a <literal>Person</literal> and an <literal>Event</literal>, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to <literal>update()</literal> or <literal>save()</literal>, Hibernate automatically detects that the collection has been modified and needs to be updated. This is called <emphasis>automatic dirty checking</emphasis>, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in <emphasis>persistent</emphasis> state, that is, bound to a particular Hibernate <literal>Session</literal> (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called <emphasis>flushing</emphasis>. In our code, the unit of work ends with a commit (or rollback) of the dat!
abase transaction - as defined by the <literal>thread</literal> configuration option for the <literal>CurrentSessionContext</literal> class."
+msgstr ""
+
+#: index.docbook:656
+msgid "You might of course load person and event in different units of work. Or you modify an object outside of a <literal>Session</literal>, when it is not in persistent state (if it was persistent before, we call this state <emphasis>detached</emphasis>). You can even modify a collection when it is detached:"
+msgstr ""
+
+#: index.docbook:663
+msgid ""
+ "<![CDATA[private void addPersonToEvent(Long personId, Long eventId) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session\n"
+ " .createQuery(\"select p from Person p left join fetch p.events where p.id = :pid\")\n"
+ " .setParameter(\"pid\", personId)\n"
+ " .uniqueResult(); // Eager fetch the collection so we can use it detached\n"
+ "\n"
+ " Event anEvent = (Event) session.load(Event.class, eventId);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "\n"
+ " // End of first unit of work\n"
+ "\n"
+ " aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached\n"
+ "\n"
+ " // Begin second unit of work\n"
+ "\n"
+ " Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session2.beginTransaction();\n"
+ "\n"
+ " session2.update(aPerson); // Reattachment of aPerson\n"
+ "\n"
+ " session2.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:665
+msgid "The call to <literal>update</literal> makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object."
+msgstr ""
+
+#: index.docbook:672
+msgid "Well, this is not much use in our current situation, but it's an important concept you can design into your own application. For now, complete this exercise by adding a new action to the <literal>EventManager</literal>'s main method and call it from the command line. If you need the identifiers of a person and an event - the <literal>save()</literal> method returns it (you might have to modify some of the previous methods to return that identifier):"
+msgstr ""
+
+#: index.docbook:680
+msgid ""
+ "<![CDATA[else if (args[0].equals(\"addpersontoevent\")) {\n"
+ " Long eventId = mgr.createAndStoreEvent(\"My Event\", new Date());\n"
+ " Long personId = mgr.createAndStorePerson(\"Foo\", \"Bar\");\n"
+ " mgr.addPersonToEvent(personId, eventId);\n"
+ " System.out.println(\"Added person \" + personId + \" to event \" + eventId);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:682
+msgid "This was an example of an association between two equally important classes, two entities. As mentioned earlier, there are other classes and types in a typical model, usually \"less important\". Some you have already seen, like an <literal>int</literal> or a <literal>String</literal>. We call these classes <emphasis>value types</emphasis>, and their instances <emphasis>depend</emphasis> on a particular entity. Instances of these types don't have their own identity, nor are they shared between entities (two persons don't reference the same <literal>firstname</literal> object, even if they have the same first name). Of course, value types can not only be found in the JDK (in fact, in a Hibernate application all JDK classes are considered value types), but you can also write dependent classes yourself, <literal>Address</literal> or <literal>MonetaryAmount</literal>, for example."
+msgstr ""
+
+#: index.docbook:695
+msgid "You can also design a collection of value types. This is conceptually very different from a collection of references to other entities, but looks almost the same in Java."
+msgstr ""
+
+#: index.docbook:703
+msgid "Collection of values"
+msgstr ""
+
+#: index.docbook:705
+msgid "We add a collection of value typed objects to the <literal>Person</literal> entity. We want to store email addresses, so the type we use is <literal>String</literal>, and the collection is again a <literal>Set</literal>:"
+msgstr ""
+
+#: index.docbook:710
+msgid ""
+ "<![CDATA[private Set emailAddresses = new HashSet();\n"
+ "\n"
+ "public Set getEmailAddresses() {\n"
+ " return emailAddresses;\n"
+ "}\n"
+ "\n"
+ "public void setEmailAddresses(Set emailAddresses) {\n"
+ " this.emailAddresses = emailAddresses;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:712
+msgid "The mapping of this <literal>Set</literal>:"
+msgstr ""
+
+#: index.docbook:716
+msgid ""
+ "<![CDATA[<set name=\"emailAddresses\" table=\"PERSON_EMAIL_ADDR\">\n"
+ " <key column=\"PERSON_ID\"/>\n"
+ " <element type=\"string\" column=\"EMAIL_ADDR\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:718
+msgid "The difference compared with the earlier mapping is the <literal>element</literal> part, which tells Hibernate that the collection does not contain references to another entity, but a collection of elements of type <literal>String</literal> (the lowercase name tells you it's a Hibernate mapping type/converter). Once again, the <literal>table</literal> attribute of the <literal>set</literal> element determines the table name for the collection. The <literal>key</literal> element defines the foreign-key column name in the collection table. The <literal>column</literal> attribute in the <literal>element</literal> element defines the column name where the <literal>String</literal> values will actually be stored."
+msgstr ""
+
+#: index.docbook:728
+msgid "Have a look at the updated schema:"
+msgstr ""
+
+#: index.docbook:732
+msgid ""
+ "<![CDATA[\n"
+ " _____________ __________________\n"
+ " | | | | _____________\n"
+ " | EVENTS | | PERSON_EVENT | | | ___________________\n"
+ " |_____________| |__________________| | PERSON | | |\n"
+ " | | | | |_____________| | PERSON_EMAIL_ADDR |\n"
+ " | *EVENT_ID | <--> | *EVENT_ID | | | |___________________|\n"
+ " | EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |\n"
+ " | TITLE | |__________________| | AGE | | *EMAIL_ADDR |\n"
+ " |_____________| | FIRSTNAME | |___________________|\n"
+ " | LASTNAME |\n"
+ " |_____________|\n"
+ " ]]>"
+msgstr ""
+
+#: index.docbook:734
+msgid "You can see that the primary key of the collection table is in fact a composite key, using both columns. This also implies that there can't be duplicate email addresses per person, which is exactly the semantics we need for a set in Java."
+msgstr ""
+
+#: index.docbook:740
+msgid "You can now try and add elements to this collection, just like we did before by linking persons and events. It's the same code in Java:"
+msgstr ""
+
+#: index.docbook:745
+msgid ""
+ "<![CDATA[private void addEmailToPerson(Long personId, String emailAddress) {\n"
+ "\n"
+ " Session session = HibernateUtil.getSessionFactory().getCurrentSession();\n"
+ " session.beginTransaction();\n"
+ "\n"
+ " Person aPerson = (Person) session.load(Person.class, personId);\n"
+ "\n"
+ " // The getEmailAddresses() might trigger a lazy load of the collection\n"
+ " aPerson.getEmailAddresses().add(emailAddress);\n"
+ "\n"
+ " session.getTransaction().commit();\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:747
+msgid "This time we didnt' use a <emphasis>fetch</emphasis> query to initialize the collection. Hence, the call to its getter method will trigger an additional select to initialize it, so we can add an element to it. Monitor the SQL log and try to optimize this with an eager fetch."
+msgstr ""
+
+#: index.docbook:757
+msgid "Bi-directional associations"
+msgstr ""
+
+#: index.docbook:759
+msgid "Next we are going to map a bi-directional association - making the association between person and event work from both sides in Java. Of course, the database schema doesn't change, we still have many-to-many multiplicity. A relational database is more flexible than a network programming language, so it doesn't need anything like a navigation direction - data can be viewed and retrieved in any possible way."
+msgstr ""
+
+#: index.docbook:767
+msgid "First, add a collection of participants to the <literal>Event</literal> Event class:"
+msgstr ""
+
+#: index.docbook:771
+msgid ""
+ "<![CDATA[private Set participants = new HashSet();\n"
+ "\n"
+ "public Set getParticipants() {\n"
+ " return participants;\n"
+ "}\n"
+ "\n"
+ "public void setParticipants(Set participants) {\n"
+ " this.participants = participants;\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:773
+msgid "Now map this side of the association too, in <literal>Event.hbm.xml</literal>."
+msgstr ""
+
+#: index.docbook:777
+msgid ""
+ "<![CDATA[<set name=\"participants\" table=\"PERSON_EVENT\" inverse=\"true\">\n"
+ " <key column=\"EVENT_ID\"/>\n"
+ " <many-to-many column=\"PERSON_ID\" class=\"events.Person\"/>\n"
+ "</set>]]>"
+msgstr ""
+
+#: index.docbook:779
+msgid "As you see, these are normal <literal>set</literal> mappings in both mapping documents. Notice that the column names in <literal>key</literal> and <literal>many-to-many</literal> are swapped in both mapping documents. The most important addition here is the <literal>inverse=\"true\"</literal> attribute in the <literal>set</literal> element of the <literal>Event</literal>'s collection mapping."
+msgstr ""
+
+#: index.docbook:787
+msgid "What this means is that Hibernate should take the other side - the <literal>Person</literal> class - when it needs to find out information about the link between the two. This will be a lot easier to understand once you see how the bi-directional link between our two entities is created ."
+msgstr ""
+
+#: index.docbook:796
+msgid "Working bi-directional links"
+msgstr ""
+
+#: index.docbook:798
+msgid "First, keep in mind that Hibernate does not affect normal Java semantics. How did we create a link between a <literal>Person</literal> and an <literal>Event</literal> in the unidirectional example? We added an instance of <literal>Event</literal> to the collection of event references, of an instance of <literal>Person</literal>. So, obviously, if we want to make this link working bi-directional, we have to do the same on the other side - adding a <literal>Person</literal> reference to the collection in an <literal>Event</literal>. This \"setting the link on both sides\" is absolutely necessary and you should never forget doing it."
+msgstr ""
+
+#: index.docbook:808
+msgid "Many developers program defensive and create link management methods to correctly set both sides, e.g. in <literal>Person</literal>:"
+msgstr ""
+
+#: index.docbook:813
+msgid ""
+ "<![CDATA[protected Set getEvents() {\n"
+ " return events;\n"
+ "}\n"
+ "\n"
+ "protected void setEvents(Set events) {\n"
+ " this.events = events;\n"
+ "}\n"
+ "\n"
+ "public void addToEvent(Event event) {\n"
+ " this.getEvents().add(event);\n"
+ " event.getParticipants().add(this);\n"
+ "}\n"
+ "\n"
+ "public void removeFromEvent(Event event) {\n"
+ " this.getEvents().remove(event);\n"
+ " event.getParticipants().remove(this);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:815
+msgid "Notice that the get and set methods for the collection are now protected - this allows classes in the same package and subclasses to still access the methods, but prevents everybody else from messing with the collections directly (well, almost). You should probably do the same with the collection on the other side."
+msgstr ""
+
+#: index.docbook:822
+msgid "What about the <literal>inverse</literal> mapping attribute? For you, and for Java, a bi-directional link is simply a matter of setting the references on both sides correctly. Hibernate however doesn't have enough information to correctly arrange SQL <literal>INSERT</literal> and <literal>UPDATE</literal> statements (to avoid constraint violations), and needs some help to handle bi-directional associations properly. Making one side of the association <literal>inverse</literal> tells Hibernate to basically ignore it, to consider it a <emphasis>mirror</emphasis> of the other side. That's all that is necessary for Hibernate to work out all of the issues when transformation a directional navigation model to a SQL database schema. The rules you have to remember are straightforward: All bi-directional associations need one side as <literal>inverse</literal>. In a one-to-many association it has to be the many-side, in many-to-many association you can pick either side, there!
is no difference."
+msgstr ""
+
+#: index.docbook:837
+msgid "Let's turn this into a small web application."
+msgstr ""
+
+#: index.docbook:844
+msgid "Part 3 - The EventManager web application"
+msgstr ""
+
+#: index.docbook:846
+msgid "A Hibernate web application uses <literal>Session</literal> and <literal>Transaction</literal> almost like a standalone application. However, some common patterns are useful. We now write an <literal>EventManagerServlet</literal>. This servlet can list all events stored in the database, and it provides an HTML form to enter new events."
+msgstr ""
+
+#: index.docbook:854
+msgid "Writing the basic servlet"
+msgstr ""
+
+#: index.docbook:856
+msgid "Create a new class in your source directory, in the <literal>events</literal> package:"
+msgstr ""
+
+#: index.docbook:861
+msgid ""
+ "<![CDATA[package events;\n"
+ "\n"
+ "// Imports\n"
+ "\n"
+ "public class EventManagerServlet extends HttpServlet {\n"
+ "\n"
+ " // Servlet code\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:863
+msgid "The servlet handles HTTP <literal>GET</literal> requests only, hence, the method we implement is <literal>doGet()</literal>:"
+msgstr ""
+
+#: index.docbook:868
+msgid ""
+ "<![CDATA[protected void doGet(HttpServletRequest request,\n"
+ " HttpServletResponse response)\n"
+ " throws ServletException, IOException {\n"
+ "\n"
+ " SimpleDateFormat dateFormatter = new SimpleDateFormat(\"dd.MM.yyyy\");\n"
+ "\n"
+ " try {\n"
+ " // Begin unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().beginTransaction();\n"
+ "\n"
+ " // Process request and render page...\n"
+ "\n"
+ " // End unit of work\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().commit();\n"
+ "\n"
+ " } catch (Exception ex) {\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().getTransaction().rollback();\n"
+ " throw new ServletException(ex);\n"
+ " }\n"
+ "\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:870
+msgid "The pattern we are applying here is called <emphasis>session-per-request</emphasis>. When a request hits the servlet, a new Hibernate <literal>Session</literal> is opened through the first call to <literal>getCurrentSession()</literal> on the <literal>SessionFactory</literal>. Then a database transaction is started—all data access as to occur inside a transaction, no matter if data is read or written (we don't use the auto-commit mode in applications)."
+msgstr ""
+
+#: index.docbook:879
+msgid "Do <emphasis>not</emphasis> use a new Hibernate <literal>Session</literal> for every database operation. Use one Hibernate <literal>Session</literal> that is scoped to the whole request. Use <literal>getCurrentSession()</literal>, so that it is automatically bound to the current Java thread."
+msgstr ""
+
+#: index.docbook:886
+msgid "Next, the possible actions of the request are processed and the response HTML is rendered. We'll get to that part soon."
+msgstr ""
+
+#: index.docbook:891
+msgid "Finally, the unit of work ends when processing and rendering is complete. If any problem occured during processing or rendering, an exception will be thrown and the database transaction rolled back. This completes the <literal>session-per-request</literal> pattern. Instead of the transaction demarcation code in every servlet you could also write a servlet filter. See the Hibernate website and Wiki for more information about this pattern, called <emphasis>Open Session in View</emphasis>—you'll need it as soon as you consider rendering your view in JSP, not in a servlet."
+msgstr ""
+
+#: index.docbook:905
+msgid "Processing and rendering"
+msgstr ""
+
+#: index.docbook:907
+msgid "Let's implement the processing of the request and rendering of the page."
+msgstr ""
+
+#: index.docbook:911
+msgid ""
+ "<![CDATA[// Write HTML header\n"
+ "PrintWriter out = response.getWriter();\n"
+ "out.println(\"<html><head><title>Event Manager</title></head><body>\");\n"
+ "\n"
+ "// Handle actions\n"
+ "if ( \"store\".equals(request.getParameter(\"action\")) ) {\n"
+ "\n"
+ " String eventTitle = request.getParameter(\"eventTitle\");\n"
+ " String eventDate = request.getParameter(\"eventDate\");\n"
+ "\n"
+ " if ( \"\".equals(eventTitle) || \"\".equals(eventDate) ) {\n"
+ " out.println(\"<b><i>Please enter event title and date.</i></b>\");\n"
+ " } else {\n"
+ " createAndStoreEvent(eventTitle, dateFormatter.parse(eventDate));\n"
+ " out.println(\"<b><i>Added event.</i></b>\");\n"
+ " }\n"
+ "}\n"
+ "\n"
+ "// Print page\n"
+ "printEventForm(out);\n"
+ "listEvents(out, dateFormatter);\n"
+ "\n"
+ "// Write HTML footer\n"
+ "out.println(\"</body></html>\");\n"
+ "out.flush();\n"
+ "out.close();]]>"
+msgstr ""
+
+#: index.docbook:913
+msgid "Granted, this coding style with a mix of Java and HTML would not scale in a more complex application—keep in mind that we are only illustrating basic Hibernate concepts in this tutorial. The code prints an HTML header and a footer. Inside this page, an HTML form for event entry and a list of all events in the database are printed. The first method is trivial and only outputs HTML:"
+msgstr ""
+
+#: index.docbook:922
+msgid ""
+ "<![CDATA[private void printEventForm(PrintWriter out) {\n"
+ " out.println(\"<h2>Add new event:</h2>\");\n"
+ " out.println(\"<form>\");\n"
+ " out.println(\"Title: <input name='eventTitle' length='50'/><br/>\");\n"
+ " out.println(\"Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>\");\n"
+ " out.println(\"<input type='submit' name='action' value='store'/>\");\n"
+ " out.println(\"</form>\");\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:924
+msgid "The <literal>listEvents()</literal> method uses the Hibernate <literal>Session</literal> bound to the current thread to execute a query:"
+msgstr ""
+
+#: index.docbook:930
+msgid ""
+ "<![CDATA[private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {\n"
+ "\n"
+ " List result = HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().createCriteria(Event.class).list();\n"
+ " if (result.size() > 0) {\n"
+ " out.println(\"<h2>Events in database:</h2>\");\n"
+ " out.println(\"<table border='1'>\");\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<th>Event title</th>\");\n"
+ " out.println(\"<th>Event date</th>\");\n"
+ " out.println(\"</tr>\");\n"
+ " for (Iterator it = result.iterator(); it.hasNext();) {\n"
+ " Event event = (Event) it.next();\n"
+ " out.println(\"<tr>\");\n"
+ " out.println(\"<td>\" + event.getTitle() + \"</td>\");\n"
+ " out.println(\"<td>\" + dateFormatter.format(event.getDate()) + \"</td>\");\n"
+ " out.println(\"</tr>\");\n"
+ " }\n"
+ " out.println(\"</table>\");\n"
+ " }\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:932
+msgid "Finally, the <literal>store</literal> action is dispatched to the <literal>createAndStoreEvent()</literal> method, which also uses the <literal>Session</literal> of the current thread:"
+msgstr ""
+
+#: index.docbook:938
+msgid ""
+ "<![CDATA[protected void createAndStoreEvent(String title, Date theDate) {\n"
+ " Event theEvent = new Event();\n"
+ " theEvent.setTitle(title);\n"
+ " theEvent.setDate(theDate);\n"
+ "\n"
+ " HibernateUtil.getSessionFactory()\n"
+ " .getCurrentSession().save(theEvent);\n"
+ "}]]>"
+msgstr ""
+
+#: index.docbook:940
+msgid "That's it, the servlet is complete. A request to the servlet will be processed in a single <literal>Session</literal> and <literal>Transaction</literal>. As earlier in the standalone application, Hibernate can automatically bind these ojects to the current thread of execution. This gives you the freedom to layer your code and access the <literal>SessionFactory</literal> in any way you like. Usually you'd use a more sophisticated design and move the data access code into data access objects (the DAO pattern). See the Hibernate Wiki for more examples."
+msgstr ""
+
+#: index.docbook:954
+msgid "Deploying and testing"
+msgstr ""
+
+#: index.docbook:956
+msgid "To deploy this application you have to create a web archive, a WAR. Add the following Ant target to your <literal>build.xml</literal>:"
+msgstr ""
+
+#: index.docbook:961
+msgid ""
+ "<![CDATA[<target name=\"war\" depends=\"compile\">\n"
+ " <war destfile=\"hibernate-tutorial.war\" webxml=\"web.xml\">\n"
+ " <lib dir=\"${librarydir}\">\n"
+ " <exclude name=\"jsdk*.jar\"/>\n"
+ " </lib>\n"
+ "\n"
+ " <classes dir=\"${targetdir}\"/>\n"
+ " </war>\n"
+ "</target>]]>"
+msgstr ""
+
+#: index.docbook:963
+msgid "This target creates a file called <literal>hibernate-tutorial.war</literal> in your project directory. It packages all libraries and the <literal>web.xml</literal> descriptor, which is expected in the base directory of your project:"
+msgstr ""
+
+#: index.docbook:969
+msgid ""
+ "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<web-app version=\"2.4\"\n"
+ " xmlns=\"http://java.sun.com/xml/ns/j2ee\"\n"
+ " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+ " xsi:schemaLocation=\"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd\">\n"
+ "\n"
+ " <servlet>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <servlet-class>events.EventManagerServlet</servlet-class>\n"
+ " </servlet>\n"
+ "\n"
+ " <servlet-mapping>\n"
+ " <servlet-name>Event Manager</servlet-name>\n"
+ " <url-pattern>/eventmanager</url-pattern>\n"
+ " </servlet-mapping>\n"
+ "</web-app>]]>"
+msgstr ""
+
+#: index.docbook:971
+msgid "Before you compile and deploy the web application, note that an additional library is required: <literal>jsdk.jar</literal>. This is the Java servlet development kit, if you don't have this library already, get it from the Sun website and copy it to your library directory. However, it will be only used for compliation and excluded from the WAR package."
+msgstr ""
+
+#: index.docbook:979
+msgid "To build and deploy call <literal>ant war</literal> in your project directory and copy the <literal>hibernate-tutorial.war</literal> file into your Tomcat <literal>webapp</literal> directory. If you don't have Tomcat installed, download it and follow the installation instructions. You don't have to change any Tomcat configuration to deploy this application though."
+msgstr ""
+
+#: index.docbook:987
+msgid "Once deployed and Tomcat is running, access the application at <literal>http://localhost:8080/hibernate-tutorial/eventmanager</literal>. Make sure you watch the Tomcat log to see Hibernate initialize when the first request hits your servlet (the static initializer in <literal>HibernateUtil</literal> is called) and to get the detailed output if any exceptions occurs."
+msgstr ""
+
+#: index.docbook:1000
+msgid "Summary"
+msgstr ""
+
+#: index.docbook:1002
+msgid "This tutorial covered the basics of writing a simple standalone Hibernate application and a small web application."
+msgstr ""
+
+#: index.docbook:1007
+msgid "If you already feel confident with Hibernate, continue browsing through the reference documentation table of contents for topics you find interesting - most asked are transactional processing (<xref linkend=\"transactions\"/>), fetch performance (<xref linkend=\"performance\"/>), or the usage of the API (<xref linkend=\"objectstate\"/>) and the query features (<xref linkend=\"objectstate-querying\"/>)."
+msgstr ""
+
+#: index.docbook:1015
+msgid "Don't forget to check the Hibernate website for more (specialized) tutorials."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/content/xml.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/content/xml.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/content/xml.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,284 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:5
+msgid "XML Mapping"
+msgstr ""
+
+#: index.docbook:7
+msgid "Note that this is an experimental feature in Hibernate 3.0 and is under extremely active development."
+msgstr ""
+
+#: index.docbook:13
+msgid "Working with XML data"
+msgstr ""
+
+#: index.docbook:15
+msgid "Hibernate lets you work with persistent XML data in much the same way you work with persistent POJOs. A parsed XML tree can be thought of as just another way to represent the relational data at the object level, instead of POJOs."
+msgstr ""
+
+#: index.docbook:22
+msgid "Hibernate supports dom4j as API for manipulating XML trees. You can write queries that retrieve dom4j trees from the database and have any modification you make to the tree automatically synchronized to the database. You can even take an XML document, parse it using dom4j, and write it to the database with any of Hibernate's basic operations: <literal>persist(), saveOrUpdate(), merge(), delete(), replicate()</literal> (merging is not yet supported)."
+msgstr ""
+
+#: index.docbook:32
+msgid "This feature has many applications including data import/export, externalization of entity data via JMS or SOAP and XSLT-based reporting."
+msgstr ""
+
+#: index.docbook:37
+msgid "A single mapping may be used to simultaneously map properties of a class and nodes of an XML document to the database, or, if there is no class to map, it may be used to map just the XML."
+msgstr ""
+
+#: index.docbook:44
+msgid "Specifying XML and class mapping together"
+msgstr ""
+
+#: index.docbook:46
+msgid "Here is an example of mapping a POJO and XML simultaneously:"
+msgstr ""
+
+#: index.docbook:50
+msgid ""
+ "<![CDATA[<class name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"accountId\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <many-to-one name=\"customer\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:54
+msgid "Specifying only an XML mapping"
+msgstr ""
+
+#: index.docbook:56
+msgid "Here is an example where there is no POJO class:"
+msgstr ""
+
+#: index.docbook:60
+msgid ""
+ "<![CDATA[<class entity-name=\"Account\" \n"
+ " table=\"ACCOUNTS\" \n"
+ " node=\"account\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"ACCOUNT_ID\" \n"
+ " node=\"@id\" \n"
+ " type=\"string\"/>\n"
+ " \n"
+ " <many-to-one name=\"customerId\" \n"
+ " column=\"CUSTOMER_ID\" \n"
+ " node=\"customer/@id\" \n"
+ " embed-xml=\"false\" \n"
+ " entity-name=\"Customer\"/>\n"
+ " \n"
+ " <property name=\"balance\" \n"
+ " column=\"BALANCE\" \n"
+ " node=\"balance\" \n"
+ " type=\"big_decimal\"/>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:62
+msgid "This mapping allows you to access the data as a dom4j tree, or as a graph of property name/value pairs (java <literal>Map</literal>s). The property names are purely logical constructs that may be referred to in HQL queries."
+msgstr ""
+
+#: index.docbook:73
+msgid "XML mapping metadata"
+msgstr ""
+
+#: index.docbook:75
+msgid "Many Hibernate mapping elements accept the <literal>node</literal> attribute. This let's you specify the name of an XML attribute or element that holds the property or entity data. The format of the <literal>node</literal> attribute must be one of the following:"
+msgstr ""
+
+#: index.docbook:84
+msgid "<literal>\"element-name\"</literal> - map to the named XML element"
+msgstr ""
+
+#: index.docbook:87
+msgid "<literal>\"@attribute-name\"</literal> - map to the named XML attribute"
+msgstr ""
+
+#: index.docbook:90
+msgid "<literal>\".\"</literal> - map to the parent element"
+msgstr ""
+
+#: index.docbook:93
+msgid "<literal>\"element-name/@attribute-name\"</literal> - map to the named attribute of the named element"
+msgstr ""
+
+#: index.docbook:100
+msgid "For collections and single valued associations, there is an additional <literal>embed-xml</literal> attribute. If <literal>embed-xml=\"true\"</literal>, the default, the XML tree for the associated entity (or collection of value type) will be embedded directly in the XML tree for the entity that owns the association. Otherwise, if <literal>embed-xml=\"false\"</literal>, then only the referenced identifier value will appear in the XML for single point associations and collections will simply not appear at all."
+msgstr ""
+
+#: index.docbook:110
+msgid "You should be careful not to leave <literal>embed-xml=\"true\"</literal> for too many associations, since XML does not deal well with circularity!"
+msgstr ""
+
+#: index.docbook:115
+msgid ""
+ "<![CDATA[<class name=\"Customer\" \n"
+ " table=\"CUSTOMER\" \n"
+ " node=\"customer\">\n"
+ " \n"
+ " <id name=\"id\" \n"
+ " column=\"CUST_ID\" \n"
+ " node=\"@id\"/>\n"
+ " \n"
+ " <map name=\"accounts\" \n"
+ " node=\".\" \n"
+ " embed-xml=\"true\">\n"
+ " <key column=\"CUSTOMER_ID\" \n"
+ " not-null=\"true\"/>\n"
+ " <map-key column=\"SHORT_DESC\" \n"
+ " node=\"@short-desc\" \n"
+ " type=\"string\"/>\n"
+ " <one-to-many entity-name=\"Account\"\n"
+ " embed-xml=\"false\" \n"
+ " node=\"account\"/>\n"
+ " </map>\n"
+ " \n"
+ " <component name=\"name\" \n"
+ " node=\"name\">\n"
+ " <property name=\"firstName\" \n"
+ " node=\"first-name\"/>\n"
+ " <property name=\"initial\" \n"
+ " node=\"initial\"/>\n"
+ " <property name=\"lastName\" \n"
+ " node=\"last-name\"/>\n"
+ " </component>\n"
+ " \n"
+ " ...\n"
+ " \n"
+ "</class>]]>"
+msgstr ""
+
+#: index.docbook:117
+msgid "in this case, we have decided to embed the collection of account ids, but not the actual account data. The following HQL query:"
+msgstr ""
+
+#: index.docbook:122
+msgid "<![CDATA[from Customer c left join fetch c.accounts where c.lastName like :lastName]]>"
+msgstr ""
+
+#: index.docbook:124
+msgid "Would return datasets such as this:"
+msgstr ""
+
+#: index.docbook:128
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account short-desc=\"Savings\">987632567</account>\n"
+ " <account short-desc=\"Credit Card\">985612323</account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+
+#: index.docbook:130
+msgid "If you set <literal>embed-xml=\"true\"</literal> on the <literal><one-to-many></literal> mapping, the data might look more like this:"
+msgstr ""
+
+#: index.docbook:135
+msgid ""
+ "<![CDATA[<customer id=\"123456789\">\n"
+ " <account id=\"987632567\" short-desc=\"Savings\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>100.29</balance>\n"
+ " </account>\n"
+ " <account id=\"985612323\" short-desc=\"Credit Card\">\n"
+ " <customer id=\"123456789\"/>\n"
+ " <balance>-2370.34</balance>\n"
+ " </account>\n"
+ " <name>\n"
+ " <first-name>Gavin</first-name>\n"
+ " <initial>A</initial>\n"
+ " <last-name>King</last-name>\n"
+ " </name>\n"
+ " ...\n"
+ "</customer>]]>"
+msgstr ""
+
+#: index.docbook:141
+msgid "Manipulating XML data"
+msgstr ""
+
+#: index.docbook:143
+msgid "Let's rearead and update XML documents in the application. We do this by obtaining a dom4j session:"
+msgstr ""
+
+#: index.docbook:148
+msgid ""
+ "<![CDATA[Document doc = ....;\n"
+ " \n"
+ "Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "List results = dom4jSession\n"
+ " .createQuery(\"from Customer c left join fetch c.accounts where c.lastName like :lastName\")\n"
+ " .list();\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " //add the customer data to the XML document\n"
+ " Element customer = (Element) results.get(i);\n"
+ " doc.add(customer);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:150
+msgid ""
+ "<![CDATA[Session session = factory.openSession();\n"
+ "Session dom4jSession = session.getSession(EntityMode.DOM4J);\n"
+ "Transaction tx = session.beginTransaction();\n"
+ "\n"
+ "Element cust = (Element) dom4jSession.get(\"Customer\", customerId);\n"
+ "for ( int i=0; i<results.size(); i++ ) {\n"
+ " Element customer = (Element) results.get(i);\n"
+ " //change the customer name in the XML and database\n"
+ " Element name = customer.element(\"name\");\n"
+ " name.element(\"first-name\").setText(firstName);\n"
+ " name.element(\"initial\").setText(initial);\n"
+ " name.element(\"last-name\").setText(lastName);\n"
+ "}\n"
+ "\n"
+ "tx.commit();\n"
+ "session.close();]]>"
+msgstr ""
+
+#: index.docbook:152
+msgid "It is extremely useful to combine this feature with Hibernate's <literal>replicate()</literal> operation to implement XML-based data import/export."
+msgstr ""
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
Added: core/trunk/documentation/manual/translations/zh-CN/legal_notice.po
===================================================================
--- core/trunk/documentation/manual/translations/zh-CN/legal_notice.po (rev 0)
+++ core/trunk/documentation/manual/translations/zh-CN/legal_notice.po 2007-10-22 15:48:10 UTC (rev 14128)
@@ -0,0 +1,48 @@
+#, fuzzy
+msgid ""
+msgstr ""
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Content-Type: text/plain; charset=utf-8\n"
+#: index.docbook:20
+msgid "Legal Notice"
+msgstr "Legal Notice"
+
+#: index.docbook:22
+msgid "<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>"
+msgstr "<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>"
+
+#: index.docbook:31
+msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, V1.0 or later (the latest version is presently available at <ulink url=\"http://www.opencontent.org/openpub/\">http://www.opencontent.org/openpub/</ulink>)."
+
+#: index.docbook:34
+msgid "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+msgstr "Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder."
+
+#: index.docbook:37
+msgid "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+msgstr "Distribution of the work or derivative of the work in any standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder."
+
+#: index.docbook:40
+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."
+
+#: index.docbook:43
+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."
+
+#: index.docbook:46
+msgid "The GPG fingerprint of the security at redhat.com key is:"
+msgstr "The GPG fingerprint of the security at redhat.com key is:"
+
+#: index.docbook:49
+msgid "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+msgstr "CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E"
+
+msgid "ROLES_OF_TRANSLATORS"
+msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"
+
+msgid "CREDIT_FOR_TRANSLATORS"
+msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"
+
More information about the hibernate-commits
mailing list